From 4a8b3569a3ac1734d3bfd71c0999035604640ca8 Mon Sep 17 00:00:00 2001 From: shana-apple <61782012+shana-apple@users.noreply.github.com> Date: Wed, 21 Oct 2020 04:22:15 +0200 Subject: [PATCH] ESP32 example app with basic and temperature cluster (#3053) * ESP32 example app with basic and temperature cluster * Review feedback * Merge copyrights * Renamed QifiEcho file * fix crash loop * restyle * Remove duplicate copyright and license notices. Silicon Labs is among CHIP Authors Co-authored-by: Rob Walker --- .../esp32/.gitignore | 1 + .../esp32/Makefile | 39 + .../esp32/README.md | 3 + .../temperature-measurement-app/esp32/idf.sh | 46 + .../esp32/main/CHIPDeviceManager.cpp | 109 + .../esp32/main/DataModelHandler.cpp | 79 + .../esp32/main/DeviceCallbacks.cpp | 97 + .../DeviceNetworkProvisioningDelegate.cpp | 26 + .../esp32/main/Kconfig.projbuild | 96 + .../esp32/main/RendezvousDeviceDelegate.cpp | 92 + .../esp32/main/RendezvousMessageHandler.cpp | 61 + .../esp32/main/ResponseServer.cpp | 171 + .../esp32/main/ServiceProvisioning.cpp | 53 + .../esp32/main/component.mk | 36 + .../esp32/main/gen/af-gen-event.h | 36 + .../esp32/main/gen/af-structs.h | 439 + .../esp32/main/gen/att-storage.h | 68 + .../esp32/main/gen/attribute-id.h | 4767 ++++ .../esp32/main/gen/attribute-size.h | 30 + .../esp32/main/gen/attribute-type.h | 84 + .../esp32/main/gen/call-command-handler.c | 122 + .../esp32/main/gen/call-command-handler.h | 31 + .../esp32/main/gen/callback-stub.c | 2475 ++ .../esp32/main/gen/callback.h | 23726 ++++++++++++++++ .../esp32/main/gen/client-command-macro.h | 8908 ++++++ .../esp32/main/gen/cluster-id.h | 155 + .../esp32/main/gen/clusters-callback-stubs.c | 385 + .../esp32/main/gen/command-id.h | 1020 + .../esp32/main/gen/debug-printing-test.h | 191 + .../esp32/main/gen/debug-printing.h | 2924 ++ .../esp32/main/gen/endpoint_config.h | 163 + .../esp32/main/gen/enums.h | 3553 +++ .../esp32/main/gen/gen_config.h | 194 + .../esp32/main/gen/gen_tokens.h | 43 + .../esp32/main/gen/print-cluster.h | 761 + .../esp32/main/gen/znet-bookkeeping.c | 100 + .../esp32/main/gen/znet-bookkeeping.h | 58 + .../esp32/main/include/CHIPDeviceManager.h | 127 + .../esp32/main/include/DataModelHandler.h | 54 + .../esp32/main/include/DeviceCallbacks.h | 47 + .../DeviceNetworkProvisioningDelegate.h | 39 + .../main/include/RendezvousDeviceDelegate.h | 40 + .../main/include/RendezvousMessageHandler.h | 36 + .../esp32/main/wifi-echo.cpp | 133 + .../esp32/partitions.csv | 6 + .../esp32/sdkconfig.defaults | 38 + .../esp32/sdkconfig_devkit.defaults | 39 + .../esp32/sdkconfig_m5stack.defaults | 39 + .../esp32/third_party/connectedhomeip | 1 + 49 files changed, 51741 insertions(+) create mode 100644 examples/temperature-measurement-app/esp32/.gitignore create mode 100644 examples/temperature-measurement-app/esp32/Makefile create mode 100644 examples/temperature-measurement-app/esp32/README.md create mode 100755 examples/temperature-measurement-app/esp32/idf.sh create mode 100644 examples/temperature-measurement-app/esp32/main/CHIPDeviceManager.cpp create mode 100644 examples/temperature-measurement-app/esp32/main/DataModelHandler.cpp create mode 100644 examples/temperature-measurement-app/esp32/main/DeviceCallbacks.cpp create mode 100644 examples/temperature-measurement-app/esp32/main/DeviceNetworkProvisioningDelegate.cpp create mode 100644 examples/temperature-measurement-app/esp32/main/Kconfig.projbuild create mode 100644 examples/temperature-measurement-app/esp32/main/RendezvousDeviceDelegate.cpp create mode 100644 examples/temperature-measurement-app/esp32/main/RendezvousMessageHandler.cpp create mode 100644 examples/temperature-measurement-app/esp32/main/ResponseServer.cpp create mode 100644 examples/temperature-measurement-app/esp32/main/ServiceProvisioning.cpp create mode 100644 examples/temperature-measurement-app/esp32/main/component.mk create mode 100644 examples/temperature-measurement-app/esp32/main/gen/af-gen-event.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/af-structs.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/att-storage.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/attribute-id.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/attribute-size.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/attribute-type.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/call-command-handler.c create mode 100644 examples/temperature-measurement-app/esp32/main/gen/call-command-handler.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/callback-stub.c create mode 100644 examples/temperature-measurement-app/esp32/main/gen/callback.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/client-command-macro.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/cluster-id.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/clusters-callback-stubs.c create mode 100644 examples/temperature-measurement-app/esp32/main/gen/command-id.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/debug-printing-test.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/debug-printing.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/endpoint_config.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/enums.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/gen_config.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/gen_tokens.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/print-cluster.h create mode 100644 examples/temperature-measurement-app/esp32/main/gen/znet-bookkeeping.c create mode 100644 examples/temperature-measurement-app/esp32/main/gen/znet-bookkeeping.h create mode 100644 examples/temperature-measurement-app/esp32/main/include/CHIPDeviceManager.h create mode 100644 examples/temperature-measurement-app/esp32/main/include/DataModelHandler.h create mode 100644 examples/temperature-measurement-app/esp32/main/include/DeviceCallbacks.h create mode 100644 examples/temperature-measurement-app/esp32/main/include/DeviceNetworkProvisioningDelegate.h create mode 100644 examples/temperature-measurement-app/esp32/main/include/RendezvousDeviceDelegate.h create mode 100644 examples/temperature-measurement-app/esp32/main/include/RendezvousMessageHandler.h create mode 100644 examples/temperature-measurement-app/esp32/main/wifi-echo.cpp create mode 100644 examples/temperature-measurement-app/esp32/partitions.csv create mode 100644 examples/temperature-measurement-app/esp32/sdkconfig.defaults create mode 100644 examples/temperature-measurement-app/esp32/sdkconfig_devkit.defaults create mode 100644 examples/temperature-measurement-app/esp32/sdkconfig_m5stack.defaults create mode 120000 examples/temperature-measurement-app/esp32/third_party/connectedhomeip diff --git a/examples/temperature-measurement-app/esp32/.gitignore b/examples/temperature-measurement-app/esp32/.gitignore new file mode 100644 index 00000000000000..b9bf8830e17ca3 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/.gitignore @@ -0,0 +1 @@ +*.vscode diff --git a/examples/temperature-measurement-app/esp32/Makefile b/examples/temperature-measurement-app/esp32/Makefile new file mode 100644 index 00000000000000..a9215726de8e5d --- /dev/null +++ b/examples/temperature-measurement-app/esp32/Makefile @@ -0,0 +1,39 @@ +# +# Copyright (c) 2020 Project CHIP Authors +# All rights reserved. +# +# 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 is a project Makefile. It is assumed the directory this Makefile resides in is a +# project subdirectory. +# + +PROJECT_NAME := chip-wifi-echo + +EXTRA_COMPONENT_DIRS += $(PROJECT_PATH)/third_party/connectedhomeip/config/esp32/components \ + $(PROJECT_PATH)/../../common/m5stack-tft/repo/components \ + $(PROJECT_PATH)/../../common/QRCode \ + $(PROJECT_PATH)/../../common/screen-framework \ + +CXXFLAGS += -std=c++11 -Os -DLWIP_IPV6_SCOPES=0 +CPPFLAGS += -Os -DLWIP_IPV6_SCOPES=0 +CFLAGS += -Os -DLWIP_IPV6_SCOPES=0 + +CHIP_BUILD_WITH_GN ?= "" + +ifneq ($(CHIP_BUILD_WITH_GN),n) +CPPFLAGS += -DCHIP_SEPARATE_CONFIG_H +endif +export CHIP_BUILD_WITH_GN +include $(IDF_PATH)/make/project.mk diff --git a/examples/temperature-measurement-app/esp32/README.md b/examples/temperature-measurement-app/esp32/README.md new file mode 100644 index 00000000000000..40e933e1d17ca7 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/README.md @@ -0,0 +1,3 @@ +# Temperature Sensor Example + +// TODO Fill this out diff --git a/examples/temperature-measurement-app/esp32/idf.sh b/examples/temperature-measurement-app/esp32/idf.sh new file mode 100755 index 00000000000000..6805596bf1fe53 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/idf.sh @@ -0,0 +1,46 @@ +#!/usr/bin/env bash +# +# Copyright (c) 2020 Project CHIP Authors +# All rights reserved. +# +# 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. + +# If this file is sourced, it exports a function called "idf" that initializes +# the espressif environment via the espressive export.sh script and runs +# a command presented as arguments +# +# This file can also be used as an executable + +error() { + echo "$me: *** ERROR: " "${*}" +} + +idf() { + [[ -d $IDF_PATH && -r $IDF_PATH/export.sh ]] || { + error "can't find IDF's export.sh, please set IDF_PATH" + return 1 + } + ( + # shellcheck source=/dev/null + . "$IDF_PATH/export.sh" + export IDF_PATH + "$@" + ) +} +if [[ ${0} == "${BASH_SOURCE[0]}" ]]; then + me=${0##*/} + idf "${@}" +else + me=idf + [[ $PS1 =~ \[idf\].* ]] || PS1="[idf]$PS1" +fi diff --git a/examples/temperature-measurement-app/esp32/main/CHIPDeviceManager.cpp b/examples/temperature-measurement-app/esp32/main/CHIPDeviceManager.cpp new file mode 100644 index 00000000000000..15fa68ddd1bc4c --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/CHIPDeviceManager.cpp @@ -0,0 +1,109 @@ +/* + * + * 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. + */ + +/** + * @file + * This file implements the CHIP Device Interface that is used by + * applications to interact with the CHIP stack + * + */ + +#include + +#include "CHIPDeviceManager.h" +#include +#include +#include +#include + +namespace chip { + +namespace DeviceManager { + +using namespace ::chip::DeviceLayer; + +void CHIPDeviceManager::CommonDeviceEventHandler(const ChipDeviceEvent * event, intptr_t arg) +{ + CHIPDeviceManagerCallbacks * cb = reinterpret_cast(arg); + if (cb != nullptr) + { + cb->DeviceEventCallback(event, reinterpret_cast(cb)); + } +} + +/** + * + */ +CHIP_ERROR CHIPDeviceManager::Init(CHIPDeviceManagerCallbacks * cb) +{ + CHIP_ERROR err; + mCB = cb; + + // Initialize the CHIP stack. + err = PlatformMgr().InitChipStack(); + SuccessOrExit(err); + + switch (static_cast(CONFIG_RENDEZVOUS_MODE)) + { + case RendezvousInformationFlags::kBLE: + ConnectivityMgr().SetBLEAdvertisingEnabled(ConnectivityManager::kCHIPoBLEServiceMode_Enabled); + break; + + case RendezvousInformationFlags::kWiFi: + ConnectivityMgr().SetBLEAdvertisingEnabled(ConnectivityManager::kCHIPoBLEServiceMode_Disabled); + ConnectivityMgr().SetWiFiAPMode(ConnectivityManager::kWiFiAPMode_Enabled); + break; + + case RendezvousInformationFlags::kNone: + // If rendezvous is bypassed, enable SoftAP so that the device can still + // be communicated with via its SoftAP as needed. + ConnectivityMgr().SetWiFiAPMode(ConnectivityManager::kWiFiAPMode_Enabled); + break; + + default: + break; + } + + err = Platform::MemoryInit(); + SuccessOrExit(err); + + // Register a function to receive events from the CHIP device layer. Note that calls to + // this function will happen on the CHIP event loop thread, not the app_main thread. + PlatformMgr().AddEventHandler(CHIPDeviceManager::CommonDeviceEventHandler, reinterpret_cast(cb)); + + // Start a task to run the CHIP Device event loop. + err = PlatformMgr().StartEventLoopTask(); + SuccessOrExit(err); + +exit: + return err; +} + +extern "C" { +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(); + if (cb != nullptr) + { + cb->PostAttributeChangeCallback(endpoint, clusterId, attributeId, mask, manufacturerCode, type, size, value); + } +} +} // extern "C" + +} // namespace DeviceManager +} // namespace chip diff --git a/examples/temperature-measurement-app/esp32/main/DataModelHandler.cpp b/examples/temperature-measurement-app/esp32/main/DataModelHandler.cpp new file mode 100644 index 00000000000000..f41d9f24241454 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/DataModelHandler.cpp @@ -0,0 +1,79 @@ +/* + * + * 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. + */ + +/** + * @file + * This file implements the handler for data model messages. + */ + +#include "esp_log.h" +#include +#include + +#include "DataModelHandler.h" + +#include "attribute-storage.h" +#include "gen/attribute-id.h" +#include "gen/cluster-id.h" +#include "gen/znet-bookkeeping.h" +#include "util.h" +#include + +using namespace ::chip; + +static const char * TAG = "data_model_server"; + +void InitDataModelHandler() +{ + emberAfEndpointConfigure(); + emAfInit(); +} + +void HandleDataModelMessage(const PacketHeader & header, System::PacketBuffer * buffer, SecureSessionMgrBase * mgr) +{ + EmberApsFrame frame; + bool ok = extractApsFrame(buffer->Start(), buffer->DataLength(), &frame) > 0; + if (ok) + { + ESP_LOGI(TAG, "APS frame processing success!"); + } + else + { + ESP_LOGI(TAG, "APS frame processing failure"); + System::PacketBuffer::Free(buffer); + return; + } + + uint8_t * message; + uint16_t messageLen = extractMessage(buffer->Start(), buffer->DataLength(), &message); + ok = emberAfProcessMessage(&frame, + 0, // type + message, messageLen, + header.GetSourceNodeId().Value(), // source identifier + nullptr); + + 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/temperature-measurement-app/esp32/main/DeviceCallbacks.cpp b/examples/temperature-measurement-app/esp32/main/DeviceCallbacks.cpp new file mode 100644 index 00000000000000..e9133d722acb74 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/DeviceCallbacks.cpp @@ -0,0 +1,97 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * All rights reserved. + * + * 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 DeviceCallbacks.cpp + * + * Implements all the callbacks to the application from the CHIP Stack + * + **/ +#include "DeviceCallbacks.h" + +#include "esp_heap_caps.h" +#include "esp_log.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::System; +using namespace ::chip::DeviceLayer; + +void DeviceCallbacks::DeviceEventCallback(const ChipDeviceEvent * event, intptr_t arg) +{ + switch (event->Type) + { + case DeviceEventType::kInternetConnectivityChange: + OnInternetConnectivityChange(event); + break; + + case DeviceEventType::kSessionEstablished: + OnSessionEstablished(event); + break; + } + + ESP_LOGI(TAG, "Current free heap: %d\n", heap_caps_get_free_size(MALLOC_CAP_8BIT)); +} + +void DeviceCallbacks::PostAttributeChangeCallback(uint8_t endpointId, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, + uint8_t * value) +{ + ESP_LOGI(TAG, "PostAttributeChangeCallback - Cluster ID: '0x%04x', EndPoint ID: '0x%02x', Attribute ID: '0x%04x'", clusterId, + endpointId, attributeId); + + // TODO handle this callback in switch statement + ESP_LOGI(TAG, "Unhandled cluster ID: %d", clusterId); + + ESP_LOGI(TAG, "Current free heap: %d\n", heap_caps_get_free_size(MALLOC_CAP_8BIT)); +} + +void DeviceCallbacks::OnInternetConnectivityChange(const ChipDeviceEvent * event) +{ + if (event->InternetConnectivityChange.IPv4 == kConnectivity_Established) + { + ESP_LOGI(TAG, "Server ready at: %s:%d", event->InternetConnectivityChange.address, CHIP_PORT); + } + else if (event->InternetConnectivityChange.IPv4 == kConnectivity_Lost) + { + ESP_LOGE(TAG, "Lost IPv4 connectivity..."); + } + if (event->InternetConnectivityChange.IPv6 == kConnectivity_Established) + { + ESP_LOGI(TAG, "IPv6 Server ready..."); + } + else if (event->InternetConnectivityChange.IPv6 == kConnectivity_Lost) + { + ESP_LOGE(TAG, "Lost IPv6 connectivity..."); + } +} + +void DeviceCallbacks::OnSessionEstablished(const ChipDeviceEvent * event) +{ + if (event->SessionEstablished.IsCommissioner) + { + ESP_LOGI(TAG, "Commissioner detected!"); + } +} diff --git a/examples/temperature-measurement-app/esp32/main/DeviceNetworkProvisioningDelegate.cpp b/examples/temperature-measurement-app/esp32/main/DeviceNetworkProvisioningDelegate.cpp new file mode 100644 index 00000000000000..8821907e5727d0 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/DeviceNetworkProvisioningDelegate.cpp @@ -0,0 +1,26 @@ +/* + * + * 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 "DeviceNetworkProvisioningDelegate.h" +#include + +using namespace ::chip; + +void ESP32NetworkProvisioningDelegate::ProvisionNetwork(const char * ssid, const char * passwd) +{ + ChipLogProgress(NetworkProvisioning, "ESP32NetworkProvisioningDelegate: Received SSID and passwd\n"); +} diff --git a/examples/temperature-measurement-app/esp32/main/Kconfig.projbuild b/examples/temperature-measurement-app/esp32/main/Kconfig.projbuild new file mode 100644 index 00000000000000..29e80d2e94b9ae --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/Kconfig.projbuild @@ -0,0 +1,96 @@ +# +# Copyright (c) 2020 Project CHIP Authors +# All rights reserved. +# +# 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: +# Configuration options CHIP ESP32 demo application. +# + +menu "WiFi Echo Demo" + + choice + prompt "Device Type" + default DEVICE_TYPE_ESP32_DEVKITC + help + Specifies the type of ESP32 device. + + Note that the "ESP32-DevKitC" choice is compatible with a number of clone devices + available from third-party manufacturers. + + config DEVICE_TYPE_ESP32_DEVKITC + bool "ESP32-DevKitC" + config DEVICE_TYPE_M5STACK + bool "M5Stack" + endchoice + + choice + prompt "Rendezvous Mode" + default RENDEZVOUS_MODE_WIFI + help + Specifies the Rendezvous mode of the peripheral. + + config RENDEZVOUS_MODE_BYPASS + bool "Bypass" + config RENDEZVOUS_MODE_WIFI + bool "Wi-Fi" + config RENDEZVOUS_MODE_BLE + bool "BLE" + config RENDEZVOUS_MODE_THREAD + bool "Thread" + config RENDEZVOUS_MODE_ETHERNET + bool "Ethernet" + endchoice + + config USE_ECHO_CLIENT + bool "Enable the built-in Echo Client" + default "n" + help + This enables a local FreeRTOS Echo Client so that the end-to-end echo server can be + tested easily + + config ECHO_HOST_IP + string "IPV4 address" + default "127.0.0.1" + depends on USE_ECHO_CLIENT + help + The IPV4 Address of the ECHO Server. + + # NOTE: This config is not displayed as a input in the Kconfig menu, as its value is + # entirely derived from the Device Type choice. However the CONFIG_EXAMPLE_DISPLAY_TYPE + # define that is produced is needed to configure the TFT library correctly. + config TFT_PREDEFINED_DISPLAY_TYPE + int + range 0 5 + default 3 if DEVICE_TYPE_M5STACK + default 0 if DEVICE_TYPE_ESP32_DEVKITC + + config RENDEZVOUS_MODE + int + range 0 8 + default 0 if RENDEZVOUS_MODE_BYPASS + default 1 if RENDEZVOUS_MODE_WIFI + default 2 if RENDEZVOUS_MODE_BLE + default 4 if RENDEZVOUS_MODE_THREAD + default 8 if RENDEZVOUS_MODE_ETHERNET + + config DISPLAY_AUTO_OFF + bool "Automatically turn off the M5Stack's Display after a few seconds" + default "y" + depends on DEVICE_TYPE_M5STACK + help + To reduce wear and heat the M5Stack's Display is automatically switched off after a few seconds + + +endmenu diff --git a/examples/temperature-measurement-app/esp32/main/RendezvousDeviceDelegate.cpp b/examples/temperature-measurement-app/esp32/main/RendezvousDeviceDelegate.cpp new file mode 100644 index 00000000000000..722dc21933ce74 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/RendezvousDeviceDelegate.cpp @@ -0,0 +1,92 @@ +/* + * + * 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 "RendezvousDeviceDelegate.h" + +#include "RendezvousMessageHandler.h" +#include "esp_log.h" +#include +#include +#include +#include + +using namespace ::chip; +using namespace ::chip::Inet; +using namespace ::chip::System; + +extern NodeId kLocalNodeId; +extern void PairingComplete(SecurePairingSession * pairing); + +static const char * TAG = "rendezvous-devicedelegate"; + +RendezvousDeviceDelegate::RendezvousDeviceDelegate() +{ + CHIP_ERROR err = CHIP_NO_ERROR; + RendezvousParameters params; + + uint32_t setupPINCode; + err = DeviceLayer::ConfigurationMgr().GetSetupPinCode(setupPINCode); + SuccessOrExit(err); + + params.SetSetupPINCode(setupPINCode).SetLocalNodeId(kLocalNodeId).SetBleLayer(DeviceLayer::ConnectivityMgr().GetBleLayer()); + + mRendezvousSession = new RendezvousSession(this, &mDeviceNetworkProvisioningDelegate); + err = mRendezvousSession->Init(params); + +exit: + if (err != CHIP_NO_ERROR) + { + ESP_LOGE(TAG, "RendezvousDeviceDelegate Init failure: %s", ErrorStr(err)); + } +} + +void RendezvousDeviceDelegate::OnRendezvousStatusUpdate(RendezvousSessionDelegate::Status status, CHIP_ERROR err) +{ + if (err != CHIP_NO_ERROR) + { + ESP_LOGE(TAG, "OnRendezvousStatusUpdate: %s, status %d", ErrorStr(err), status); + } + + switch (status) + { + case RendezvousSessionDelegate::SecurePairingSuccess: + ESP_LOGI(TAG, "Device completed SPAKE2+ handshake\n"); + PairingComplete(&mRendezvousSession->GetPairingSession()); + break; + + case RendezvousSessionDelegate::NetworkProvisioningSuccess: + + ESP_LOGI(TAG, "Device was assigned an ip address\n"); + break; + + default: + break; + }; +} + +void RendezvousDeviceDelegate::OnRendezvousMessageReceived(PacketBuffer * buffer) +{ + ESP_LOGI(TAG, "OnRendezvousMessageReceived"); + + // When paired, offer the RendezvousMessageHandler a chance to process the message. + CHIP_ERROR err = RendezvousMessageHandler::HandleMessageReceived(buffer); + if (err == CHIP_ERROR_INVALID_MESSAGE_TYPE) + { + // If the handler did not recognize the message, treat it as an echo request. + mRendezvousSession->SendMessage(buffer); + } +} diff --git a/examples/temperature-measurement-app/esp32/main/RendezvousMessageHandler.cpp b/examples/temperature-measurement-app/esp32/main/RendezvousMessageHandler.cpp new file mode 100644 index 00000000000000..32935d470ade61 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/RendezvousMessageHandler.cpp @@ -0,0 +1,61 @@ +/* + * + * 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 "RendezvousMessageHandler.h" +#include +#include +#include +#include + +using namespace ::chip; + +extern CHIP_ERROR SetWiFiStationProvisioning(char * ssid, char * key); + +CHIP_ERROR RendezvousMessageHandler::HandleMessageReceived(System::PacketBuffer * buffer) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + bool isWiFiCredentials = false; + char * key = nullptr; + char * ssid = nullptr; + + // Pending definition of an actual message format, WiFi credentials have the form + // ‘::SSID:password:’, where ‘:’ can be any single ASCII character. + constexpr size_t maxBufferLen = + 4 + chip::DeviceLayer::Internal::kMaxWiFiSSIDLength + chip::DeviceLayer::Internal::kMaxWiFiKeyLength; + char msg[maxBufferLen]; + + const size_t bufferLen = buffer->DataLength(); + VerifyOrExit(bufferLen < sizeof msg, err = CHIP_ERROR_INVALID_MESSAGE_TYPE); + memcpy(msg, buffer->Start(), bufferLen); + msg[bufferLen] = 0; + ChipLogProgress(NetworkProvisioning, "RendezvousMessageHandler: Receive message: %s", msg); + + isWiFiCredentials = ((bufferLen > 3) && (msg[0] == msg[1]) && (msg[0] == msg[bufferLen - 1])); + VerifyOrExit(isWiFiCredentials, err = CHIP_ERROR_INVALID_MESSAGE_TYPE); + + msg[1] = 0; + ssid = strtok(&msg[2], msg); + key = strtok(NULL, msg); + VerifyOrExit(ssid && key, err = CHIP_ERROR_INVALID_MESSAGE_TYPE); + + ChipLogProgress(NetworkProvisioning, "RendezvousMessageHandler: SSID: %s, key: %s", ssid, key); + err = SetWiFiStationProvisioning(ssid, key); + SuccessOrExit(err); + +exit: + return err; +} diff --git a/examples/temperature-measurement-app/esp32/main/ResponseServer.cpp b/examples/temperature-measurement-app/esp32/main/ResponseServer.cpp new file mode 100644 index 00000000000000..08963d9e2e547d --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/ResponseServer.cpp @@ -0,0 +1,171 @@ +/* + * + * 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 "esp_event.h" +#include "esp_log.h" +#include "esp_system.h" +#include "esp_wifi.h" +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "nvs_flash.h" + +#include +#include +#include +#include +#include + +#include "lwip/err.h" +#include "lwip/sockets.h" +#include "lwip/sys.h" +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "DataModelHandler.h" + +static const char * TAG = "echo_server"; + +using namespace ::chip; +using namespace ::chip::Inet; +using namespace ::chip::Transport; + +extern const NodeId kLocalNodeId = 12344321; + +namespace { + +class ResponseServerCallback : public SecureSessionMgrDelegate +{ +public: + void OnMessageReceived(const PacketHeader & header, Transport::PeerConnectionState * state, System::PacketBuffer * buffer, + SecureSessionMgrBase * mgr) override + { + CHIP_ERROR err; + const size_t data_len = buffer->DataLength(); + + // as soon as a client connects, assume it is connected + VerifyOrExit(mgr != nullptr && buffer != nullptr, ESP_LOGE(TAG, "Received data but couldn't process it...")); + VerifyOrExit(state->GetPeerNodeId() != kUndefinedNodeId, ESP_LOGE(TAG, "Unknown source for received message")); + + { + char src_addr[Transport::PeerAddress::kMaxToStringSize]; + + state->GetPeerAddress().ToString(src_addr, sizeof(src_addr)); + + ESP_LOGI(TAG, "Packet received from %s: %zu bytes", src_addr, static_cast(data_len)); + } + + HandleDataModelMessage(header, buffer, mgr); + buffer = nullptr; + + exit: + + // SendTo calls Free on the buffer without an AddRef, if SendTo was not called, free the buffer. + if (buffer != nullptr) + { + System::PacketBuffer::Free(buffer); + } + } + + void OnReceiveError(CHIP_ERROR error, const Transport::PeerAddress & source, SecureSessionMgrBase * mgr) override + { + ESP_LOGE(TAG, "ERROR: %s\n Got UDP error", ErrorStr(error)); + } + + void OnNewConnection(Transport::PeerConnectionState * state, SecureSessionMgrBase * mgr) override + { + ESP_LOGI(TAG, "Received a new connection."); + } + +private: + /** + * A data model message has nonzero length and always has a first byte whose + * value is one of: 0x00, 0x01, 0x02, 0x03. See chipZclEncodeZclHeader for the + * construction of the message and in particular the first byte. + * + * Echo messages should generally not have a first byte with those values, so we + * can use that to try to distinguish between the two. + */ + bool ContentMayBeADataModelMessage(System::PacketBuffer * buffer) + { + const size_t data_len = buffer->DataLength(); + const uint8_t * data = buffer->Start(); + bool maybeDataModelMessage = true; + + // Has to have nonzero length. + VerifyOrExit(data_len > 0, maybeDataModelMessage = false); + + // Has to have a valid first byte value. + VerifyOrExit(data[0] < 0x04, maybeDataModelMessage = false); + + exit: + return maybeDataModelMessage; + } +}; + +ResponseServerCallback gCallbacks; + +SecureSessionMgr + sessions; + +} // namespace + +namespace chip { +SecureSessionMgrBase & SessionManager() +{ + return sessions; +} +} // namespace chip + +void PairingComplete(SecurePairingSession * pairing) +{ + Optional peer(Transport::Type::kUndefined); + sessions.NewPairing(peer, pairing); +} + +// The echo server assumes the platform's networking has been setup already +void startServer() +{ + CHIP_ERROR err = CHIP_NO_ERROR; + err = sessions.Init(kLocalNodeId, &DeviceLayer::SystemLayer, + UdpListenParameters(&DeviceLayer::InetLayer).SetAddressType(kIPAddressType_IPv6).SetInterfaceId(nullptr), + UdpListenParameters(&DeviceLayer::InetLayer).SetAddressType(kIPAddressType_IPv4)); + SuccessOrExit(err); + + sessions.SetDelegate(&gCallbacks); + +exit: + if (err != CHIP_NO_ERROR) + { + ESP_LOGE(TAG, "ERROR setting up transport: %s", ErrorStr(err)); + } + else + { + ESP_LOGI(TAG, "Echo Server Listening..."); + } +} diff --git a/examples/temperature-measurement-app/esp32/main/ServiceProvisioning.cpp b/examples/temperature-measurement-app/esp32/main/ServiceProvisioning.cpp new file mode 100644 index 00000000000000..fc01e9bb21b015 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/ServiceProvisioning.cpp @@ -0,0 +1,53 @@ +/* + * + * 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 +#include +#include + +#include "esp_wifi.h" + +using namespace ::chip::DeviceLayer; + +CHIP_ERROR SetWiFiStationProvisioning(char * ssid, char * key) +{ + ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_Disabled); + + CHIP_ERROR err = CHIP_NO_ERROR; + wifi_config_t wifiConfig; + + // Set the wifi configuration + memset(&wifiConfig, 0, sizeof(wifiConfig)); + memcpy(wifiConfig.sta.ssid, ssid, strlen(ssid) + 1); + memcpy(wifiConfig.sta.password, key, strlen(key) + 1); + wifiConfig.sta.scan_method = WIFI_ALL_CHANNEL_SCAN; + wifiConfig.sta.sort_method = WIFI_CONNECT_AP_BY_SIGNAL; + + // Configure the ESP WiFi interface. + err = esp_wifi_set_config(ESP_IF_WIFI_STA, &wifiConfig); + if (err != ESP_OK) + { + ChipLogError(DeviceLayer, "esp_wifi_set_config() failed: %s", chip::ErrorStr(err)); + } + SuccessOrExit(err); + + ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_Disabled); + ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_Enabled); + +exit: + return err; +} diff --git a/examples/temperature-measurement-app/esp32/main/component.mk b/examples/temperature-measurement-app/esp32/main/component.mk new file mode 100644 index 00000000000000..7f8233b2e78382 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/component.mk @@ -0,0 +1,36 @@ +# +# Copyright (c) 2020 Project CHIP Authors +# All rights reserved. +# +# 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: +# Component makefile for the ESP32 demo application. +# +# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.) + +COMPONENT_DEPENDS := chip QRCode tft spidriver + +COMPONENT_SRCDIRS := \ + . \ + gen \ + ../third_party/connectedhomeip/src/app/util \ + ../third_party/connectedhomeip/src/app/clusters/basic \ + ../third_party/connectedhomeip/src/app/clusters/temperature-measurement-server \ + + +COMPONENT_EXTRA_INCLUDES := $(PROJECT_PATH)/third_party/connectedhomeip/src/app/util \ + $(PROJECT_PATH)/third_party/connectedhomeip/src + +# So "gen/*" files are found by the src/app bits. +COMPONENT_PRIV_INCLUDEDIRS := . diff --git a/examples/temperature-measurement-app/esp32/main/gen/af-gen-event.h b/examples/temperature-measurement-app/esp32/main/gen/af-gen-event.h new file mode 100644 index 00000000000000..e4c05d8133a3ef --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/af-gen-event.h @@ -0,0 +1,36 @@ +/** + * + * 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. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// Enclosing macro to prevent multiple inclusion +#ifndef __AF_GEN_EVENT__ +#define __AF_GEN_EVENT__ + +// Code used to configure the cluster event mechanism +#define EMBER_AF_GENERATED_EVENT_CODE \ + extern EmberEventControl emberAfPluginTemperatureMeasurementServerReadEventControl; \ + extern void emberAfPluginTemperatureMeasurementServerReadEventHandler(void); + +// EmberEventData structs used to populate the EmberEventData table +#define EMBER_AF_GENERATED_EVENTS \ + { &emberAfPluginTemperatureMeasurementServerReadEventControl, emberAfPluginTemperatureMeasurementServerReadEventHandler }, + +#define EMBER_AF_GENERATED_EVENT_STRINGS "Temperature Measurement Server Cluster Plugin Read", + +#endif // __AF_GEN_EVENT__ diff --git a/examples/temperature-measurement-app/esp32/main/gen/af-structs.h b/examples/temperature-measurement-app/esp32/main/gen/af-structs.h new file mode 100644 index 00000000000000..12c9364e76becd --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/af-structs.h @@ -0,0 +1,439 @@ +/** + * + * 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. + */ +// 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/temperature-measurement-app/esp32/main/gen/att-storage.h b/examples/temperature-measurement-app/esp32/main/gen/att-storage.h new file mode 100644 index 00000000000000..f3122982e72b81 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/att-storage.h @@ -0,0 +1,68 @@ +/** + * + * Copyright (c) 2020 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +// 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/temperature-measurement-app/esp32/main/gen/attribute-id.h b/examples/temperature-measurement-app/esp32/main/gen/attribute-id.h new file mode 100644 index 00000000000000..0b3523bb7e9459 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/attribute-id.h @@ -0,0 +1,4767 @@ +/** + * + * 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. + */ +// 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/temperature-measurement-app/esp32/main/gen/attribute-size.h b/examples/temperature-measurement-app/esp32/main/gen/attribute-size.h new file mode 100644 index 00000000000000..7620e27a5cc56d --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/attribute-size.h @@ -0,0 +1,30 @@ +/** + * + * 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. + */ +// 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/temperature-measurement-app/esp32/main/gen/attribute-type.h b/examples/temperature-measurement-app/esp32/main/gen/attribute-type.h new file mode 100644 index 00000000000000..6f60f6af8ad2c3 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/attribute-type.h @@ -0,0 +1,84 @@ +/** + * + * 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. + */ +// 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/temperature-measurement-app/esp32/main/gen/call-command-handler.c b/examples/temperature-measurement-app/esp32/main/gen/call-command-handler.c new file mode 100644 index 00000000000000..fef98ddbb8cf0a --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/call-command-handler.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. + */ +// 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. + +#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 "af-structs.h" +#include "call-command-handler.h" +#include "callback.h" +#include "command-id.h" +#include "util.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) + { + case ZCL_BASIC_CLUSTER_ID: + result = status(false, true, cmd->mfgSpecific); + break; + case ZCL_TEMP_MEASUREMENT_CLUSTER_ID: + result = status(false, true, cmd->mfgSpecific); + break; + default: + // Unrecognized cluster ID, error status will apply. + break; + } + } + else if (cmd->direction == (uint8_t) ZCL_DIRECTION_CLIENT_TO_SERVER && + emberAfContainsServerWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode)) + { + switch (cmd->apsFrame->clusterId) + { + case ZCL_BASIC_CLUSTER_ID: + result = emberAfBasicClusterServerCommandParse(cmd); + break; + case ZCL_TEMP_MEASUREMENT_CLUSTER_ID: + result = status(false, true, cmd->mfgSpecific); + break; + default: + // Unrecognized cluster ID, error status will apply. + break; + } + } + return result; +} + +// Cluster: Basic, server +EmberAfStatus emberAfBasicClusterServerCommandParse(EmberAfClusterCommand * cmd) +{ + bool wasHandled = false; + if (!cmd->mfgSpecific) + { + switch (cmd->commandId) + { + case ZCL_RESET_TO_FACTORY_DEFAULTS_COMMAND_ID: { + // Command is fixed length: 0 + wasHandled = emberAfBasicClusterResetToFactoryDefaultsCallback(); + break; + } + default: { + // Unrecognized command ID, error status will apply. + break; + } + } + } + return status(wasHandled, true, cmd->mfgSpecific); +} diff --git a/examples/temperature-measurement-app/esp32/main/gen/call-command-handler.h b/examples/temperature-measurement-app/esp32/main/gen/call-command-handler.h new file mode 100644 index 00000000000000..dcfc47bebe09b5 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/call-command-handler.h @@ -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. + */ +// 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 + +#include "af-types.h" + +// This is a set of generated prototype for functions that parse the +// the incomming message, and call appropriate command handler. + +// Cluster: Basic, server +EmberAfStatus emberAfBasicClusterServerCommandParse(EmberAfClusterCommand * cmd); + +#endif // SILABS_EMBER_AF_COMMAND_PARSE_HEADER diff --git a/examples/temperature-measurement-app/esp32/main/gen/callback-stub.c b/examples/temperature-measurement-app/esp32/main/gen/callback-stub.c new file mode 100644 index 00000000000000..7f9c642dac6c23 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/callback-stub.c @@ -0,0 +1,2475 @@ +/** + * + * 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. + */ +// 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 "callback.h" + +#include +//#include "hal/hal.h" + +/** @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 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) +{ + 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 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) +{ + // 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 Reset To Factory Defaults + * + * This function is called by the Basic server plugin when a request to reset + * to factory defaults is received. The plugin will reset attributes managed by + * the framework to their default values. The application should perform any + * other necessary reset-related operations in this callback, including + * resetting any externally-stored attributes. + * + * @param endpoint Ver.: always + */ +void emberAfPluginBasicResetToFactoryDefaultsCallback(uint8_t endpoint) {} + +/** @brief Over temperature state changed + * + * This callback is generated when the temperature rises over the assert + * thresholds (warning and critical) or drops below the deassert thresholds + * (warning and critical) + * + * @param previousState, the state prior to the state change + * + * @param newState, the new state of the state change + * + * EMBER_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE_NORMAL : normal state + * EMBER_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE_WARNING : warning state + * EMBER_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE_CRITICAL : critical state + * + * Ver.: always + */ +void emberAfPluginTemperatureMeasurementServerOverTemperatureCallback(uint8_t previousState, uint8_t newState) {} + +// 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 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 Key Establishment Cluster Server Command Received + * + * This function is called by the application framework when a client-to-server + * key establishment command is received but has yet to be handled by the + * framework code. This function should return a bool value indicating whether + * the command has been handled by the application code and should not be + * further processed by the framework. + * + * @param cmd Ver.: always + */ +bool emberAfKeyEstablishmentClusterServerCommandReceivedCallback(EmberAfClusterCommand * cmd) +{ + return false; +} + +/** @brief Set Default Poll Control + * + * This function will set the default poll control for the current network to + * control whether or not it can long poll. + * + * @param control Ver.: always + */ +void emberAfSetDefaultPollControlCallback(EmberAfEventPollControl control) {} + +/** @brief Set Default Sleep Control + * + * This function will set the default behavior of a sleeping device to control + * whether or not it must stay awake. A device that stays awake does not sleep + * at all. Otherwise, the device can sleep between events when appropriate. + * + * @param control Ver.: always + */ +void emberAfSetDefaultSleepControlCallback(EmberAfEventSleepControl control) {} + +/** @brief Set Form And Join Extended Pan Id + * + * This callback is called by the framework to set the extended PAN ID used by + * the current network for forming and joining. The extended PAN ID used for + * forming and joining is not necessarily the same extended PAN ID actually in + * use on the network. + * + * @param extendedPanId Ver.: always + */ +void emberAfSetFormAndJoinExtendedPanIdCallback(const uint8_t * extendedPanId) {} + +/** @brief Set Long Poll Interval Ms + * + * This function is only useful to end devices. This function will set the long + * poll interval (in milliseconds) for the current network. This interval is + * the maximum amount of time a child will wait between polls of its parent when + * it is not expecting data. + * + * @param longPollIntervalMs Ver.: always + */ +void emberAfSetLongPollIntervalMsCallback(uint32_t longPollIntervalMs) {} + +/** @brief Set Long Poll Interval Qs + * + * This function is only useful to end devices. This function will set the long + * poll interval (in quarter seconds) for the current network. This interval is + * the maximum amount of time a child will wait between polls of its parent when + * it is not expecting data. + * + * @param longPollIntervalQs Ver.: always + */ +void emberAfSetLongPollIntervalQsCallback(uint32_t longPollIntervalQs) {} + +/** @brief Set Short Poll Interval Ms + * + * This function is only useful to sleepy end devices. This function will set + * the short poll interval (in milliseconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is expecting data. + * + * @param shortPollIntervalMs Ver.: always + */ +void emberAfSetShortPollIntervalMsCallback(uint16_t shortPollIntervalMs) {} + +/** @brief Set Short Poll Interval Qs + * + * This function is only useful to sleepy end devices. This function will set + * the short poll interval (in quarter seconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is expecting data. + * + * @param shortPollIntervalQs Ver.: always + */ +void emberAfSetShortPollIntervalQsCallback(uint16_t shortPollIntervalQs) {} + +/** @brief Set Source Route Overhead + * + * This function is called by the framework when it has information about the + * source route overhead to a particular destination. The application may use + * this information to cache the source route overhead. + * + * @param destination The node id of the destination Ver.: always + * @param overhead The overhead in bytes Ver.: always + */ +void emberAfSetSourceRouteOverheadCallback(EmberNodeId destination, uint8_t overhead) {} + +/** @brief Set Time + * + * This callback should be implemented, if the device has access to real time + * clock, and has an ability to update that clock. The application framework + * expects to be passed the utcTime which is the number of seconds since the + * year 2000. Default implementation does nothing. Note: This function used to + * take time in year, month, day, hour, min, sec. We have changed this to + * utcTime in order to conserve code space. + * + * @param utcTime Ver.: always + */ +void emberAfSetTimeCallback(uint32_t utcTime) {} + +/** @brief On/off Cluster Set Value + * + * This function is called when the on/off value needs to be set, either through + * normal channels or as a result of a level change. + * + * @param endpoint Ver.: always + * @param command Ver.: always + * @param initiatedByLevelChange Ver.: always + */ +EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, uint8_t command, bool initiatedByLevelChange) +{ + return EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND; +} + +/** @brief Set Wake Timeout Bitmask + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout bitmask for the current network. The bitmask determines + * which tasks will timeout automatically and which tasks require manual removal + * from the task list. + * + * @param tasks Ver.: always + */ +void emberAfSetWakeTimeoutBitmaskCallback(EmberAfApplicationTask tasks) {} + +/** @brief Set Wake Timeout Ms + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout (in milliseconds) for the current network. This timeout is + * the maximum amount of time a child will wait for a task in the wake bitmask + * to finish. While waiting, the device will short poll. + * + * @param wakeTimeoutMs Ver.: always + */ +void emberAfSetWakeTimeoutMsCallback(uint16_t wakeTimeoutMs) {} + +/** @brief Set Wake Timeout Qs + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout (in quarter seconds) for the current network. This timeout + * is the maximum amount of time a child will wait for a task in the wake + * bitmask to finish. While waiting, the device will short poll. + * + * @param wakeTimeoutQs Ver.: always + */ +void emberAfSetWakeTimeoutQsCallback(uint16_t wakeTimeoutQs) {} + +/** @brief Start Move + * + * This function is called to initiate the process for a device to move (rejoin) + * to a new parent. + * + */ +bool emberAfStartMoveCallback(void) +{ + return false; +} + +/** @brief Start Search For Joinable Network + * + * This function is called by the framework to search for joinable networks and + * join a network. The application should return EMBER_SUCCESS if the operation + * was initiated successfully. + * + */ +EmberStatus emberAfStartSearchForJoinableNetworkCallback(void) +{ + return EMBER_LIBRARY_NOT_PRESENT; +} + +/** @brief Stop Move + * + * This function is called to cancel a previously scheduled move (rejoin) to a + * new parent. + * + */ +void emberAfStopMoveCallback(void) {} + +/** @brief Scenes Cluster Store Current Scene + * + * This function is called by the framework when the application should store + * the current scene. If an entry already exists in the scene table with the + * same scene and group ids, the application should update the entry with the + * current scene. Otherwise, a new entry should be adde to the scene table, if + * possible. + * + * @param endpoint The endpoint. Ver.: always + * @param groupId The group identifier. Ver.: always + * @param sceneId The scene identifier. Ver.: always + */ +EmberAfStatus emberAfScenesClusterStoreCurrentSceneCallback(uint8_t endpoint, uint16_t groupId, uint8_t sceneId) +{ + return EMBER_ZCL_STATUS_FAILURE; +} + +/** @brief Trust Center Join + * + * This callback is called from within the application framework's + * implementation of emberTrustCenterJoinHandler or ezspTrustCenterJoinHandler. + * This callback provides the same arguments passed to the + * TrustCenterJoinHandler. For more information about the TrustCenterJoinHandler + * please see documentation included in stack/include/trust-center.h. + * + * @param newNodeId Ver.: always + * @param newNodeEui64 Ver.: always + * @param parentOfNewNode Ver.: always + * @param status Ver.: always + * @param decision Ver.: always + */ +void emberAfTrustCenterJoinCallback(EmberNodeId newNodeId, EmberEUI64 newNodeEui64, EmberNodeId parentOfNewNode, + EmberDeviceUpdate status, EmberJoinDecision decision) +{} + +/** @brief Trust Center Keepalive Abort + * + * This callback is called when the device should abort the trust center + * keepalive process. + * + */ +void emberAfTrustCenterKeepaliveAbortCallback(void) {} + +/** @brief Trust Center Keepalive Update + * + * This callback is called when the device finishes registration (successfully + * or otherwise) and the trust center keepalive process must be updated. If the + * keepalive process has not been started, then it is started. Otherwise if the + * keepalive is in the process of searching for the TC, it will process the + * result of that Trust Center search operation. + * + * @param registrationComplete Ver.: always + */ +void emberAfTrustCenterKeepaliveUpdateCallback(bool registrationComplete) {} + +/** @brief Unused Pan Id Found + * + * This is called by the framework on behalf of the form-and-join library to + * notify the application of the PAN id and channel found following a call to + * ::emberScanForUnusedPanId(). See form-and-join documentation for more + * information. + * + * @param panId Ver.: always + * @param channel Ver.: always + */ +void emberAfUnusedPanIdFoundCallback(EmberPanId panId, uint8_t channel) {} + +/** @brief Write Attributes Response + * + * This function is called by the application framework when a Write Attributes + * Response command is received from an external device. The application should + * return true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of write attribute status records. + * Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfWriteAttributesResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen) +{ + return false; +} + +/** @brief Zigbee Key Establishment + * + * A callback to the application to notify it of the status of the request for a + * Link Key. + * + * @param partner partner The IEEE address of the partner device. Or all zeros + * if the Key establishment failed. Ver.: always + * @param status The status of the key establishment. Ver.: always + */ +void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status) {} + +/** + * @brief Called whenever the radio is powered off. + */ +void halRadioPowerDownHandler(void) {} + +/** + * @brief Called whenever the radio is powered on. + */ +void halRadioPowerUpHandler(void) {} + +/** + * @brief Called whenever the microcontroller enters/exits a idle/sleep mode + * + * @param enter True if entering idle/sleep, False if exiting + * @param sleepMode Idle/sleep mode + */ +void halSleepCallback(bool enter, SleepModes sleepMode) {} diff --git a/examples/temperature-measurement-app/esp32/main/gen/callback.h b/examples/temperature-measurement-app/esp32/main/gen/callback.h new file mode 100644 index 00000000000000..99002ce3c5c92e --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/callback.h @@ -0,0 +1,23726 @@ +/** + * + * 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. + */ +// 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" + +#ifdef __cplusplus +extern "C" { +#endif // #ifdef __cplusplus + +/** @name Non-Cluster Related Callbacks */ +// @{ +/** @brief Add To Current App Tasks + * + * This function is only useful to sleepy end devices. This function will note + * the passed item as part of a set of tasks the application has outstanding + * (e.g. message sent requiring APS acknwoledgement). This will affect how the + * application behaves with regard to sleeping and polling. Until the + * outstanding task is completed, the device may poll more frequently and sleep + * less often. + * + * @param tasks Ver.: always + */ +void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks); +/** @brief Allow Network Write Attribute + * + * This function is called by the application framework before it writes an + * attribute in response to a write attribute request from an external device. + * The value passed into this callback is the value to which the attribute is to + * be set by the framework. + Example: In mirroring simple metering data + * on an Energy Services Interface (ESI) (formerly called Energy Service Portal + * (ESP) in SE 1.0).), a mirrored simple meter needs to write read-only + * attributes on its mirror. The-meter-mirror sample application, located in + * app/framework/sample-apps, uses this callback to allow the mirrored device to + * write simple metering attributes on the mirror regardless of the fact that + * most simple metering attributes are defined as read-only by the ZigBee + * specification. + Note: The ZCL specification does not (as of this + * writing) specify any permission-level security for writing writeable + * attributes. As far as the ZCL specification is concerned, if an attribute is + * writeable, any device that has a link key for the device should be able to + * write that attribute. Furthermore if an attribute is read only, it should not + * be written over the air. Thus, if you implement permissions for writing + * attributes as a feature, you MAY be operating outside the specification. This + * is unlikely to be a problem for writing read-only attributes, but it may be a + * problem for attributes that are writeable according to the specification but + * restricted by the application implementing this callback. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param value Ver.: always + * @param type Ver.: always + */ +EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeId attributeId, uint8_t mask, + uint16_t manufacturerCode, uint8_t * value, uint8_t type); +/** @brief Attribute Read Access + * + * This function is called whenever the Application Framework needs to check + * access permission for an attribute read. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param manufacturerCode Ver.: always + * @param attributeId Ver.: always + */ +bool emberAfAttributeReadAccessCallback(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode, + uint16_t attributeId); +/** @brief Attribute Write Access + * + * This function is called whenever the Application Framework needs to check + * access permission for an attribute write. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param manufacturerCode Ver.: always + * @param attributeId Ver.: always + */ +bool emberAfAttributeWriteAccessCallback(uint8_t endpoint, EmberAfClusterId clusterId, uint16_t manufacturerCode, + uint16_t attributeId); +/** @brief Clear Report Table + * + * This function is called by the framework when the application should clear + * the report table. + * + */ +EmberStatus emberAfClearReportTableCallback(void); +/** @brief Cluster Init + * + * This function is called when a specific cluster is initialized. It gives the + * application an opportunity to take care of cluster initialization procedures. + * It is called exactly once for each endpoint where cluster is present. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + */ +void emberAfClusterInitCallback(uint8_t endpoint, EmberAfClusterId clusterId); +/** @brief Cluster Security Custom + * + * This callback is fired when determining if APS encryption is required for a + * cluster outside of the specification's required clusters. In other words, + * for the Smart Energy profile this would be a cluster beyond the list that + * normally requires APS encryption. + * + * @param profileId The profile ID Ver.: always + * @param clusterId The cluster ID Ver.: always + * @param incoming Whether this is an incoming or outgoing message. Ver.: + * always + * @param commandId The ZCL command ID being sent/received. Ver.: always + */ +bool emberAfClusterSecurityCustomCallback(EmberAfProfileId profileId, EmberAfClusterId clusterId, bool incoming, uint8_t commandId); +/** @brief Configure Reporting Command + * + * This function is called by the application framework when a Configure + * Reporting command is received from an external device. The Configure + * Reporting command contains a series of attribute reporting configuration + * records. The application should return true if the message was processed or + * false if it was not. + * + * @param cmd Ver.: always + */ +bool emberAfConfigureReportingCommandCallback(const EmberAfClusterCommand * cmd); +/** @brief Configure Reporting Response + * + * This function is called by the application framework when a Configure + * Reporting Response command is received from an external device. The + * application should return true if the message was processed or false if it + * was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of attribute status records. Ver.: + * always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfConfigureReportingResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); +/** @brief Default Response + * + * This function is called by the application framework when a Default Response + * command is received from an external device. The application should return + * true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param commandId The command identifier to which this is a response. Ver.: + * always + * @param status Specifies either SUCCESS or the nature of the error that was + * detected in the received command. Ver.: always + */ +bool emberAfDefaultResponseCallback(EmberAfClusterId clusterId, uint8_t commandId, EmberAfStatus status); +/** @brief Discover Attributes Response + * + * This function is called by the application framework when a Discover + * Attributes Response or Discover Attributes Extended Response command is + * received from an external device. The Discover Attributes Response command + * contains a bool indicating if discovery is complete and a list of zero or + * more attribute identifier/type records. The final argument indicates whether + * the response is in the extended format or not. The application should return + * true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param discoveryComplete Indicates whether there are more attributes to be + * discovered. true if there are no more attributes to be discovered. Ver.: + * always + * @param buffer Buffer containing the list of attribute identifier/type + * records. Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + * @param extended Indicates whether the response is in the extended format or + * not. Ver.: always + */ +bool emberAfDiscoverAttributesResponseCallback(EmberAfClusterId clusterId, bool discoveryComplete, uint8_t * buffer, + uint16_t bufLen, bool extended); +/** @brief Discover Commands Generated Response + * + * This function is called by the framework when Discover Commands Generated + * Response is received. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param manufacturerCode Manufacturer code Ver.: always + * @param discoveryComplete Indicates whether there are more commands to be + * discovered. Ver.: always + * @param commandIds Buffer containing the list of command identifiers. Ver.: + * always + * @param commandIdCount The length of bytes of the list, whish is the same as + * the number of identifiers. Ver.: always + */ +bool emberAfDiscoverCommandsGeneratedResponseCallback(EmberAfClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete, + uint8_t * commandIds, uint16_t commandIdCount); +/** @brief Discover Commands Received Response + * + * This function is called by the framework when Discover Commands Received + * Response is received. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param manufacturerCode Manufacturer code Ver.: always + * @param discoveryComplete Indicates whether there are more commands to be + * discovered. Ver.: always + * @param commandIds Buffer containing the list of command identifiers. Ver.: + * always + * @param commandIdCount The length of bytes of the list, whish is the same as + * the number of identifiers. Ver.: always + */ +bool emberAfDiscoverCommandsReceivedResponseCallback(EmberAfClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete, + uint8_t * commandIds, uint16_t commandIdCount); +/** @brief Eeprom Init + * + * Tells the system to initialize the EEPROM if it is not already initialized. + * + */ +void emberAfEepromInitCallback(void); +/** @brief Eeprom Note Initialized State + * + * Records the state of the EEPROM so that an intelligent driver (like the + * EEPROM plugin) can re-initialize the driver prior to any calls to it. + * + * @param state The state of the EEPROM, false=re-initalization needed, + * true=no-re-init needed Ver.: always + */ +void emberAfEepromNoteInitializedStateCallback(bool state); +/** @brief Eeprom Shutdown + * + * Tells the system to shutdown the EEPROM if it is not already shutdown. + * + */ +void emberAfEepromShutdownCallback(void); +/** @brief Energy Scan Result + * + * This is called by the low-level stack code when an 802.15.4 energy scan + * completes. + * + * @param channel The channel where the energy scan took place. Ver.: always + * @param rssi The receive signal strength indicator for the channel. Ver.: + * always + */ +void emberAfEnergyScanResultCallback(uint8_t channel, int8_t rssi); +/** @brief External Attribute Read + * + * Like emberAfExternalAttributeWriteCallback above, this function is called + * when the framework needs to read an attribute that is not stored within the + * Application Framework's data structures. + All of the important + * information about the attribute itself is passed as a pointer to an + * EmberAfAttributeMetadata struct, which is stored within the application and + * used to manage the attribute. A complete description of the + * EmberAfAttributeMetadata struct is provided in + * app/framework/include/af-types.h + This function assumes that the + * application is able to read the attribute, write it into the passed buffer, + * and return immediately. Any attributes that require a state machine for + * reading and writing are not really candidates for externalization at the + * present time. The Application Framework does not currently include a state + * machine for reading or writing attributes that must take place across a + * series of application ticks. Attributes that cannot be read in a timely + * manner should be stored within the Application Framework and updated + * occasionally by the application code from within the + * emberAfMainTickCallback. + If the application was successfully able to + * read the attribute and write it into the passed buffer, it should return a + * value of EMBER_ZCL_STATUS_SUCCESS. Ensure that the size of the externally + * managed attribute value is smaller than what the buffer can hold. In the case + * of a buffer overflow throw an appropriate error such as + * EMBER_ZCL_STATUS_INSUFFICIENT_SPACE. Any other return value indicates the + * application was not able to read the attribute. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeMetadata Ver.: always + * @param manufacturerCode Ver.: always + * @param buffer Ver.: always + * @param maxReadLength Ver.: always + */ +EmberAfStatus emberAfExternalAttributeReadCallback(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode, + uint8_t * buffer, uint16_t maxReadLength); +/** @brief External Attribute Write + * + * This function is called whenever the Application Framework needs to write an + * attribute which is not stored within the data structures of the Application + * Framework itself. One of the new features in Version 2 is the ability to + * store attributes outside the Framework. This is particularly useful for + * attributes that do not need to be stored because they can be read off the + * hardware when they are needed, or are stored in some central location used by + * many modules within the system. In this case, you can indicate that the + * attribute is stored externally. When the framework needs to write an external + * attribute, it makes a call to this callback. + This callback is very + * useful for host micros which need to store attributes in persistent memory. + * Because each host micro (used with an Ember NCP) has its own type of + * persistent memory storage, the Application Framework does not include the + * ability to mark attributes as stored in flash the way that it does for Ember + * SoCs like the EM35x. On a host micro, any attributes that need to be stored + * in persistent memory should be marked as external and accessed through the + * external read and write callbacks. Any host code associated with the + * persistent storage should be implemented within this callback. + All of + * the important information about the attribute itself is passed as a pointer + * to an EmberAfAttributeMetadata struct, which is stored within the application + * and used to manage the attribute. A complete description of the + * EmberAfAttributeMetadata struct is provided in + * app/framework/include/af-types.h. + This function assumes that the + * application is able to write the attribute and return immediately. Any + * attributes that require a state machine for reading and writing are not + * candidates for externalization at the present time. The Application Framework + * does not currently include a state machine for reading or writing attributes + * that must take place across a series of application ticks. Attributes that + * cannot be written immediately should be stored within the Application + * Framework and updated occasionally by the application code from within the + * emberAfMainTickCallback. + If the application was successfully able to + * write the attribute, it returns a value of EMBER_ZCL_STATUS_SUCCESS. Any + * other return value indicates the application was not able to write the + * attribute. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeMetadata Ver.: always + * @param manufacturerCode Ver.: always + * @param buffer Ver.: always + */ +EmberAfStatus emberAfExternalAttributeWriteCallback(uint8_t endpoint, EmberAfClusterId clusterId, + EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode, + uint8_t * buffer); +/** @brief Find Unused Pan Id And Form + * + * This function is called by the framework to search for an unused PAN id and + * form a new network. The application should return EMBER_SUCCESS if the + * operation was initiated successfully. + * + */ +EmberStatus emberAfFindUnusedPanIdAndFormCallback(void); +/** @brief Get Current App Tasks + * + * This function is only useful to sleepy end devices. This function will + * return the set of tasks the application has outstanding. These tasks affect + * how the application behaves with regard to sleeping and polling. + * + */ +EmberAfApplicationTask emberAfGetCurrentAppTasksCallback(void); +/** @brief Get Current Poll Control + * + * This function will retrieve the current poll control that the system is using + * for the current network. This is determined by examining all the scheduled + * events and obtaining the most restrictive poll control context across all + * events. The most restrictive poll control is EMBER_AF_SHORT_POLL followed by + * EMBER_AF_LONG_POLL. + * + */ +EmberAfEventPollControl emberAfGetCurrentPollControlCallback(void); +/** @brief Get Current Poll Interval Ms + * + * This function is only useful to end devices. This function will return the + * current poll interval (in milliseconds) for the current network. This + * interval is the maximum amount of time a child is currently waiting between + * polls of its parent. + * + */ +uint32_t emberAfGetCurrentPollIntervalMsCallback(void); +/** @brief Get Current Poll Interval Qs + * + * This function is only useful to end devices. This function will return the + * current poll interval (in quarter seconds) for the current network. This + * interval is the maximum amount of time a child is currently waiting between + * polls of its parent. + * + */ +uint32_t emberAfGetCurrentPollIntervalQsCallback(void); +/** @brief Get Current Sleep Control + * + * This function will retrieve the current sleep control that the system is + * using. This is determined by examining all the scheduled events and + * obtaining the most restrictive sleep control context across all events. The + * most restrictive sleep control is EMBER_AF_STAY_AWAKE followed by + * EMBER_AF_OK_TO_SLEEP. + * + */ +EmberAfEventSleepControl emberAfGetCurrentSleepControlCallback(void); +/** @brief Get Current Time + * + * This callback is called when device attempts to get current time from the + * hardware. If this device has means to retrieve exact time, then this method + * should implement it. If the callback can't provide the exact time it should + * return 0 to indicate failure. Default action is to return 0, which indicates + * that device does not have access to real time. + * + */ +uint32_t emberAfGetCurrentTimeCallback(void); +/** @brief Get Default Poll Control + * + * This function will retrieve the default poll control for the current network + * as previously set by emberAfSetDefaultPollControlCallback(). The default + * poll control will limit whether the network can long poll. + * + */ +EmberAfEventPollControl emberAfGetDefaultPollControlCallback(void); +/** @brief Get Default Sleep Control + * + * This function will retrieve the default sleep control the system is using as + * previously set by emberAfSetDefaultSleepControlCallback(). The default sleep + * control will limit whether the device can sleep. + * + */ +EmberAfEventSleepControl emberAfGetDefaultSleepControlCallback(void); +/** @brief Get Endpoint By Index + * + * Get the endpoint number based on the passed index. By default the framework + * handles this by managing endpoints based on the precompiled configuration + * defined in AppBuilder. This callback can override this behavior at runtime + * and provide additional endpoints or different data than the compiled values. + * If the index is overridden than the callback shall return true and set the + * endpointReturn parameter accordingly. A value of 0xFF means the endpoint + * doesn't exist at that index. + Otherwise false must be returned by the + * callback and the default framework behavior will be executed. This is only + * applicable to the SOC devices. + * + * @param index The index of the endpoint. Ver.: always + * @param endpointReturn The value of endpoint. Ver.: always + */ +bool emberAfGetEndpointByIndexCallback(uint8_t index, uint8_t * endpointReturn); +/** @brief Get Endpoint Description + * + * This callback is called by the framework whenever it receives a ZDO request + * to enumerate the details about an endpoint. By default the framework + * provides the information based on the precompiled endpoint information as + * defined in AppBuilder. This callback can override that behavior at runtime + * and return different information. If the endpoint information is being + * overridden then the callback must return true. Otherwise it should return + * false, which allows the framework to perform its default behavior. This is + * only applicable to SOC devices. + * + * @param endpoint The endpoint number that is being queried. Ver.: always + * @param result This is a pointer to a data structure where the endpoint + * information is written if the callback is providing the information. Ver.: + * always + */ +bool emberAfGetEndpointDescriptionCallback(uint8_t endpoint, EmberEndpointDescription * result); +/** @brief Get Endpoint Info + * + * This function is a callback to an application implemented endpoint that + * operates outside the normal application framework. When the framework wishes + * to perform operations with that endpoint it uses this callback to retrieve + * the endpoint's information. If the endpoint exists and the application can + * provide data then true shall be returned. Otherwise the callback must return + * false. + * + * @param endpoint The endpoint to retrieve data for. Ver.: always + * @param returnNetworkIndex The index corresponding to the ZigBee network the + * endpoint belongs to. If not using a multi-network device, 0 must be + * returned. Otherwise on a multi-network device the stack will switch to this + * network before sending the message. Ver.: always + * @param returnEndpointInfo A pointer to a data struct that will be written + * with information about the endpoint. Ver.: always + */ +bool emberAfGetEndpointInfoCallback(uint8_t endpoint, uint8_t * returnNetworkIndex, EmberAfEndpointInfoStruct * returnEndpointInfo); +/** @brief Get Form And Join Extended Pan Id + * + * This callback is called by the framework to get the extended PAN ID used by + * the current network for forming and joining. The extended PAN ID used for + * forming and joining is not necessarily the same extended PAN ID actually in + * use on the network. + * + * @param resultLocation Ver.: always + */ +void emberAfGetFormAndJoinExtendedPanIdCallback(uint8_t * resultLocation); +/** @brief Get Long Poll Interval Ms + * + * This function is only useful to end devices. This function will return the + * long poll interval (in milliseconds) for the current network. This interval + * is the maximum amount of time a child will wait between polls of its parent + * when it is not expecting data. + * + */ +uint32_t emberAfGetLongPollIntervalMsCallback(void); +/** @brief Get Long Poll Interval Qs + * + * This function is only useful to end devices. This function will return the + * long poll interval (in quarter seconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is not expecting data. + * + */ +uint32_t emberAfGetLongPollIntervalQsCallback(void); +/** @brief Get Short Poll Interval Ms + * + * This function is only useful to sleepy end devices. This function will + * return the short poll interval (in milliseconds) for the current network. + * This interval is the maximum amount of time a child will wait between polls + * of its parent when it is expecting data. + * + */ +uint16_t emberAfGetShortPollIntervalMsCallback(void); +/** @brief Get Short Poll Interval Qs + * + * This function is only useful to sleepy end devices. This function will + * return the short poll interval (in quarter seconds) for the current network. + * This interval is the maximum amount of time a child will wait between polls + * of its parent when it is expecting data. + * + */ +uint16_t emberAfGetShortPollIntervalQsCallback(void); +/** @brief Get Source Route Overhead + * + * This function is called by the framework to determine the overhead required + * in the network frame for source routing to a particular destination. + * + * @param destination The node id of the destination Ver.: always + */ +uint8_t emberAfGetSourceRouteOverheadCallback(EmberNodeId destination); +/** @brief Get Wake Timeout Bitmask + * + * This function is only useful to sleepy end devices. This function will + * return the wake timeout bitmask for the current network. The bitmask + * determines which tasks will timeout automatically and which tasks require + * manual removal from the task list. + * + */ +EmberAfApplicationTask emberAfGetWakeTimeoutBitmaskCallback(void); +/** @brief Get Wake Timeout Ms + * + * This function is only useful to sleepy end devices. This function will + * return the wake timeout (in milliseconds) for the current network. This + * timeout is the maximum amount of time a child will wait for a task in the + * wake bitmask to finish. While waiting, the device will short poll. + * + */ +uint16_t emberAfGetWakeTimeoutMsCallback(void); +/** @brief Get Wake Timeout Qs + * + * This function is only useful to sleepy end devices. This function will + * return the wake timeout (in quarter seconds) for the current network. This + * timeout is the maximum amount of time a child will wait for a task in the + * wake bitmask to finish. While waiting, the device will short poll. + * + */ +uint16_t emberAfGetWakeTimeoutQsCallback(void); +/** @brief Hal Button Isr + * + * This callback is called by the framework whenever a button is pressed on the + * device. This callback is called within ISR context. + * + * @param button The button which has changed state, either BUTTON0 or BUTTON1 + * as defined in the appropriate BOARD_HEADER. Ver.: always + * @param state The new state of the button referenced by the button parameter, + * either ::BUTTON_PRESSED if the button has been pressed or ::BUTTON_RELEASED + * if the button has been released. Ver.: always + */ +void emberAfHalButtonIsrCallback(uint8_t button, uint8_t state); +/** @brief Incoming Packet Filter + * + * ** REQUIRES INCLUDING THE PACKET-HANDOFF PLUGIN ** + + This is called by + * the Packet Handoff plugin when the stack receives a packet from one of the + * protocol layers specified in ::EmberZigbeePacketType. + + The packetType + * argument is one of the values of the ::EmberZigbeePacketType enum. If the + * stack receives an 802.15.4 MAC beacon, it will call this function with the + * packetType argument set to ::EMBER_ZIGBEE_PACKET_TYPE_BEACON. + + The + * implementation of this callback may alter the data contained in packetData, + * modify options and flags in the auxillary data, or consume the packet itself, + * either sending the message, or discarding it as it sees fit. + * + * @param packetType the type of packet and associated protocol layer Ver.: + * always + * @param packetData flat buffer containing the packet data associated with the + * packet type Ver.: always + * @param size_p a pointer containing the size value of the packet Ver.: always + * @param data auxillary data included with the packet Ver.: always + */ +EmberPacketAction emberAfIncomingPacketFilterCallback(EmberZigbeePacketType packetType, uint8_t * packetData, uint8_t * size_p, + void * data); +/** @brief Initiate Inter Pan Key Establishment + * + * This function is called by the framework to initiate key establishment with a + * remote device on a different PAN. The application should return + * EMBER_SUCCESS if key establishment was initiated successfully. The + * application should call ::emberAfInterPanKeyEstablishmentCallback as events + * occur. + * + * @param panId The PAN id of the remote device. Ver.: always + * @param eui64 The EUI64 of the remote device. Ver.: always + */ +EmberStatus emberAfInitiateInterPanKeyEstablishmentCallback(EmberPanId panId, const EmberEUI64 eui64); +/** @brief Initiate Key Establishment + * + * This function is called by the framework to initiate key establishment with a + * remote device. The application should return EMBER_SUCCESS if key + * establishment was initiated successfully. The application should call + * ::emberAfKeyEstablishmentCallback as events occur. + * + * @param nodeId The node id of the remote device. Ver.: always + * @param endpoint The endpoint on the remote device. Ver.: always + */ +EmberStatus emberAfInitiateKeyEstablishmentCallback(EmberNodeId nodeId, uint8_t endpoint); +/** @brief Initiate Partner Link Key Exchange + * + * This function is called by the framework to initiate a partner link key + * exchange with a remote device. The application should return EMBER_SUCCESS + * if the partner link key exchange was initiated successfully. When the + * partner link key exchange completes, the application should call the given + * callback. + * + * @param target The node id of the remote device. Ver.: always + * @param endpoint The key establishment endpoint of the remote device. Ver.: + * always + * @param callback The callback that should be called when the partner link key + * exchange completse. Ver.: always + */ +EmberStatus emberAfInitiatePartnerLinkKeyExchangeCallback(EmberNodeId target, uint8_t endpoint, + EmberAfPartnerLinkKeyExchangeCallback * callback); +/** @brief Inter Pan Key Establishment + * + * A callback by the key-establishment code to indicate an event has occurred. + * For error codes this is purely a notification. For non-error status codes + * (besides LINK_KEY_ESTABLISHED), it is the application's chance to allow or + * disallow the operation. If the application returns true then the key + * establishment is allowed to proceed. If it returns false, then key + * establishment is aborted. LINK_KEY_ESTABLISHED is a notification of success. + * + * @param status Ver.: always + * @param amInitiator Ver.: always + * @param panId Ver.: always + * @param eui64 Ver.: always + * @param delayInSeconds Ver.: always + */ +bool emberAfInterPanKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, bool amInitiator, EmberPanId panId, + const EmberEUI64 eui64, uint8_t delayInSeconds); +/** @brief Interpan Send Message + * + * This function will send a raw MAC message with interpan frame format using + * the passed parameters. + * + * @param header Interpan header info Ver.: always + * @param messageLength The length of the message received or to send Ver.: + * always + * @param message The message data received or to send. Ver.: always + */ +EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader * header, uint16_t messageLength, uint8_t * message); +/** @brief Key Establishment + * + * A callback by the key-establishment code to indicate an event has occurred. + * For error codes this is purely a notification. For non-error status codes + * (besides LINK_KEY_ESTABLISHED), it is the application's chance to allow or + * disallow the operation. If the application returns true then the key + * establishment is allowed to proceed. If it returns false, then key + * establishment is aborted. LINK_KEY_ESTABLISHED is a notification of success. + * + * @param status Ver.: always + * @param amInitiator Ver.: always + * @param partnerShortId Ver.: always + * @param delayInSeconds Ver.: always + */ +bool emberAfKeyEstablishmentCallback(EmberAfKeyEstablishmentNotifyMessage status, bool amInitiator, EmberNodeId partnerShortId, + uint8_t delayInSeconds); +/** @brief Main Init + * + * This function is called from the application's main function. It gives the + * application a chance to do any initialization required at system startup. Any + * code that you would normally put into the top of the application's main() + * routine should be put into this function. This is called before the clusters, + * plugins, and the network are initialized so some functionality is not yet + * available. + Note: No callback in the Application Framework is + * associated with resource cleanup. If you are implementing your application on + * a Unix host where resource cleanup is a consideration, we expect that you + * will use the standard Posix system calls, including the use of atexit() and + * handlers for signals such as SIGTERM, SIGINT, SIGCHLD, SIGPIPE and so on. If + * you use the signal() function to register your signal handler, please mind + * the returned value which may be an Application Framework function. If the + * return value is non-null, please make sure that you call the returned + * function from your handler to avoid negating the resource cleanup of the + * Application Framework itself. + * + */ +void emberAfMainInitCallback(void); +/** @brief Main Start + * + * This function is called at the start of main after the HAL has been + * initialized. The standard main function arguments of argc and argv are + * passed in. However not all platforms have support for main() function + * arguments. Those that do not are passed NULL for argv, therefore argv should + * be checked for NULL before using it. If the callback determines that the + * program must exit, it should return true. The value returned by main() will + * be the value written to the returnCode pointer. Otherwise the callback + * should return false to let normal execution continue. + * + * @param returnCode Ver.: always + * @param argc Ver.: always + * @param argv Ver.: always + */ +bool emberAfMainStartCallback(int * returnCode, int argc, char ** argv); +/** @brief Main Tick + * + * Whenever main application tick is called, this callback will be called at the + * end of the main tick execution. + * + */ +void emberAfMainTickCallback(void); +/** @brief Mark Buffers + * + * This function is called when the garbage collector runs. Any buffers held by + * the application must be marked. + * + */ +void emberAfMarkBuffersCallback(void); +/** @brief Message Sent + * + * This function is called by the application framework from the message sent + * handler, when it is informed by the stack regarding the message sent status. + * All of the values passed to the emberMessageSentHandler are passed on to this + * callback. This provides an opportunity for the application to verify that its + * message has been sent successfully and take the appropriate action. This + * callback should return a bool value of true or false. A value of true + * indicates that the message sent notification has been handled and should not + * be handled by the application framework. + * + * @param type Ver.: always + * @param indexOrDestination Ver.: always + * @param apsFrame Ver.: always + * @param msgLen Ver.: always + * @param message Ver.: always + * @param status Ver.: always + */ +bool emberAfMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Ncp Init + * + * This function is called when the network coprocessor is being initialized, + * either at startup or upon reset. It provides applications on opportunity to + * perform additional configuration of the NCP. The function is always called + * twice when the NCP is initialized. In the first invocation, memoryAllocation + * will be true and the application should only issue EZSP commands that affect + * memory allocation on the NCP. For example, tables on the NCP can be resized + * in the first call. In the second invocation, memoryAllocation will be false + * and the application should only issue EZSP commands that do not affect memory + * allocation. For example, tables on the NCP can be populated in the second + * call. This callback is not called on SoCs. + * + * @param memoryAllocation Ver.: always + */ +void emberAfNcpInitCallback(bool memoryAllocation); +/** @brief Ncp Is Awake Isr + * + * This function is called IN ISR CONTEXT. It notes that the NCP is awake after + * sleeping. Care should be taken to do minimal processing in this ISR handler + * function. + * + */ +void emberAfNcpIsAwakeIsrCallback(void); +/** @brief Network Found + * + * This callback is generated when an active scan finds a 802.15.4 network. + * + * @param networkFound A struct containing information about the network found. + * Ver.: always + * @param lqi The link quality indication of the network found. Ver.: always + * @param rssi The received signal strength indication of the network found. + * Ver.: always + */ +void emberAfNetworkFoundCallback(EmberZigbeeNetwork * networkFound, uint8_t lqi, int8_t rssi); +/** @brief Network Key Update Complete + * + * This is called by the framework when a network key update operation started + * by the trust center is complete. + * + * @param status Ver.: always + */ +void emberAfNetworkKeyUpdateCompleteCallback(EmberStatus status); +/** @brief Ota Bootload + * + * The platform specific routine to bootload the device from a ZigBee + * over-the-air upgrade file. + * + * @param id A pointer to the structure that contains the information about what + * OTA image to bootload. Ver.: always + * @param ncpUpgradeTagId The tag ID of the upgrade data that will be used to + * bootload the device. Ver.: always + */ +uint8_t emberAfOtaBootloadCallback(const EmberAfOtaImageId * id, uint16_t ncpUpgradeTagId); +/** @brief Ota Client Bootload + * + * This callback is fired when the OTA Client recevies a command to bootload the + * newly downloaded OTA image. This callback will perform the platform specific + * to bootload their device. + * + * @param id This is the identifier relating to the image that has been + * downloaded and is ready for bootload. Ver.: always + */ +void emberAfOtaClientBootloadCallback(const EmberAfOtaImageId * id); +/** @brief Ota Client Custom Verify + * + * This callback is executed by the OTA client after the signature verification + * has successfully completed. It allows the device to do its own custom + * verification of the image (such as verifying that the EBL is intact). + * + * @param newVerification This indicates if a new verification should be + * started. Ver.: always + * @param id This is ID of the image to be verified. Ver.: always + */ +EmberAfImageVerifyStatus emberAfOtaClientCustomVerifyCallback(bool newVerification, const EmberAfOtaImageId * id); +/** @brief Ota Client Download Complete + * + * This callback indicates that the OTA client has completed the download of a + * file. If the file has been completely downloaded and cryptographic checks + * have been turned on, then those will be performed prior to this callback and + * that outcome included in the 'success' result. On failure, this callback is + * merely informative, and the return type is ignored. On succesful download, + * this callback allows the client to perform any additional verification of the + * downloaded image and return that result to the OTA server. + * + * @param success This indicates the success or failure of the download and + * cryptographic verification process (if applicable). Ver.: always + * @param id This is the image identifier information that corresponds to the + * download result. Ver.: always + */ +bool emberAfOtaClientDownloadCompleteCallback(EmberAfOtaDownloadResult success, const EmberAfOtaImageId * id); +/** @brief Ota Client Incoming Message Raw + * + * This callback is for processing incoming messages for the Over-the-air + * bootload cluster client. ZCL will not process the message and instead hand + * the raw over the air data to the callback for its own processing. + * + * @param message A pointer to the structure containing the message buffer and + * other information about it. Ver.: always + */ +bool emberAfOtaClientIncomingMessageRawCallback(EmberAfClusterCommand * message); +/** @brief Ota Client Start + * + * This callback should be called when the profile specific registration has + * completed successfully. It will start the client's state machine that will + * find the OTA server, query it for the next image, download the image, wait + * for the bootload message, and kick off the bootload. + * + */ +void emberAfOtaClientStartCallback(void); +/** @brief Ota Client Version Info + * + * This function is called by the OTA client when a new query will occur to the + * server asking what the next version of firmware is. The client can inform + * the cluster software as to what information to use in the query (and + * subsequent download). + * + * @param currentImageInfo This is the information to use in the next query by + * the client cluster code. It contains the manufacturer ID, image type ID, and + * the firmware version to be specified in the query message sent to the server. + * Ver.: always + * @param hardwareVersion This is a pointer to the hardware version to use in + * the query. If no hardware version should be used, then + * EMBER_AF_INVALID_HARDWARE_VERSION should be used. Ver.: always + */ +void emberAfOtaClientVersionInfoCallback(EmberAfOtaImageId * currentImageInfo, uint16_t * hardwareVersion); +/** @brief Ota Page Request Server Policy + * + * This callback is called by the OTA server page request code when it wants to + * determine if it is allowed for an OTA client to make a page request. It is + * only called if page request support has been enabled on the server. It + * should return EMBER_ZCL_STATUS_SUCCESS if it allows the page request, and + * EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND if it does not want to allow it. + * + */ +uint8_t emberAfOtaPageRequestServerPolicyCallback(void); +/** @brief Ota Server Block Size + * + * This function provides a way for the server to adjust the block size of its + * response to an Image block request by a client. + * + * @param clientNodeId The node Id of OTA client making an image block request. + * Ver.: always + */ +uint8_t emberAfOtaServerBlockSizeCallback(EmberNodeId clientNodeId); +/** @brief Ota Server Incoming Message Raw + * + * This callback is for processing incoming messages for the Over-the-air + * bootload cluster server. ZCL will not process the message and instead hand + * the raw over the air data to the callback for its own processing. + * + * @param message A pointer to the structure containing the message buffer and + * other information about it. Ver.: always + */ +bool emberAfOtaServerIncomingMessageRawCallback(EmberAfClusterCommand * message); +/** @brief Ota Server Query + * + * This callback is fired when the OTA server receives a query request by the + * client. The callback lets the server application indicate to the client what + * the 'next' version of software is for the device, or if there is not one + * available. + * + * @param currentImageId This is the current software image that the client + * hase. Ver.: always + * @param hardwareVersion If this value is non-NULL, it indicates the hardware + * version of the client device. If NULL, the client did not specify a hardware + * version. Ver.: always + * @param nextUpgradeImageId This is a pointer to a data structure containing + * the 'next' software version for the client to download. Ver.: always + */ +uint8_t emberAfOtaServerQueryCallback(const EmberAfOtaImageId * currentImageId, uint16_t * hardwareVersion, + EmberAfOtaImageId * nextUpgradeImageId); +/** @brief Ota Server Send Image Notify + * + * This callback is an indication to the OTA server that it should send out + * notification about an OTA file that is available for download. + * + * @param dest The destination of the image notify message. May be a broadcast + * address. Ver.: always + * @param endpoint The destination endpoint of the image notify message. May be + * a broadcast endpoint. Ver.: always + * @param payloadType The type of data the image notify message will contain. 0 + * = no data. 1 = Manufacturer ID. 2 = Manufacturer ID and the image type ID. + * 3 = Manufacturer ID, image type ID, and firmware version. Ver.: always + * @param queryJitter The percentage of nodes that should respond to this + * message, from 1-100. On receipt of this message, each recipient will + * randomly choose a percentage and only query the server if their percentage is + * below this value. Ver.: always + * @param id The image information that will be put in the message. The data + * within this struct that will be appended to the message is determined by the + * previous 'payloadType' argument. Ver.: always + */ +bool emberAfOtaServerSendImageNotifyCallback(EmberNodeId dest, uint8_t endpoint, uint8_t payloadType, uint8_t queryJitter, + const EmberAfOtaImageId * id); +/** @brief Ota Server Upgrade End Request + * + * This function is called when the OTA server receives a request an upgrade end + * request. If the request indicated a successful download by the client, the + * server must tell the client when and if to upgrade to the downloaded image. + * + * @param source The node ID of the device that sent the upgrade end request. + * Ver.: always + * @param status This is the ZCL status sent by the client indicating the result + * of its attempt to download the new upgrade image. If the status is not + * EMBER_ZCL_STATUS_SUCCESS then this callback is merely informative and no + * response mesasge will be generated by the server. Ver.: always + * @param returnValue If the server returns true indicating that the client + * should apply the upgrade, this time value indicates when in the future the + * client should apply the upgrade. Ver.: always + * @param imageId This variable indicates the software version that the client + * successfully downloaded and is asking to upgrade to. Ver.: always + */ +bool emberAfOtaServerUpgradeEndRequestCallback(EmberNodeId source, uint8_t status, uint32_t * returnValue, + const EmberAfOtaImageId * imageId); +/** @brief Ota Storage Check Temp Data + * + * This callback will validate temporary data in the storage device to determine + * whether it is a complete file, a partially downloaded file, or there is no + * file present. When a complete or partial file is found it will return + * EMBER_AF_OTA_STORAGE_SUCCESS or EMBER_AF_OTA_STORAGE_PARTIAL_FILE_FOUND, + * respectively. In that case, the currentOffset, totalImageSize, and + * newFileInfo will be populated with data. When EMBER_AF_OTA_STORAGE_ERROR is + * returned, no temporary data is present. + * + * @param currentOffset A pointer to a value that will be written with the + * offset within the total file size that has been successfully stored in the + * storage device. This will indicate how much data has been currently + * dowloaded. Ver.: always + * @param totalImageSize A pointer to a value that will be written with the + * total image size of the OTA file when a download has completed. This does + * not indicate how much data has actually been downloaded currently. Ver.: + * always + * @param newFileInfo This is the image id of the temporary file data stored in + * the storage device. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageCheckTempDataCallback(uint32_t * currentOffset, uint32_t * totalImageSize, + EmberAfOtaImageId * newFileInfo); +/** @brief Ota Storage Clear Temp Data + * + * This function clears any existing temp data that was downloaed. It is used + * immediately prior to downloading a raw image over the air. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageClearTempDataCallback(void); +/** @brief Ota Storage Close + * + * This callback shuts down the ZigBee Over-the-air storage module. + * + */ +void emberAfOtaStorageCloseCallback(void); +/** @brief Ota Storage Driver Download Finish + * + * This callback defines the low-level means by which a device records the final + * offset value of the download image. + * + * @param offset The value of the final offset of the image download. Ver.: + * always + */ +void emberAfOtaStorageDriverDownloadFinishCallback(uint32_t offset); +/** @brief Ota Storage Driver Init + * + * The initialization code for the OTA storage driver. + * + */ +bool emberAfOtaStorageDriverInitCallback(void); +/** @brief Ota Storage Driver Invalidate Image + * + * This callback invalidates the image stored on disk so that it will not be + * bootloaded, and it will not be a valid image that is in the middle of + * downloading. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageDriverInvalidateImageCallback(void); +/** @brief Ota Storage Driver Prepare To Resume Download + * + * This callback allows the underlying storage driver to prepare to resume the + * OTA file download. For example, the driver may exceute a page erase to + * insure the next page is ready to be written to. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageDriverPrepareToResumeDownloadCallback(void); +/** @brief Ota Storage Driver Read + * + * This callback defines the low-level means by which a device reads from the + * OTA storage device. + * + * @param offset The address offset from the start of the storage device where + * data is to be read. Ver.: always + * @param length The length of the data to be read from the storage device. + * Ver.: always + * @param returnData A pointer where the data read from the device should be + * written to. Ver.: always + */ +bool emberAfOtaStorageDriverReadCallback(uint32_t offset, uint32_t length, uint8_t * returnData); +/** @brief Ota Storage Driver Retrieve Last Stored Offset + * + * This callback defines the low-level means by which a device retrieves the + * last persistently recorded download offset. This may be different than last + * actual download offset. + * + */ +uint32_t emberAfOtaStorageDriverRetrieveLastStoredOffsetCallback(void); +/** @brief Ota Storage Driver Write + * + * This callback defines the low-level means by which a device reads from the + * OTA storage device. + * + * @param dataToWrite A pointer to the data that will be written to the storage + * device. Ver.: always + * @param offset The address offset from the start of the storage device where + * data will be written. Ver.: always + * @param length The length of the data to be written to the storage device. + * Ver.: always + */ +bool emberAfOtaStorageDriverWriteCallback(const uint8_t * dataToWrite, uint32_t offset, uint32_t length); +/** @brief Ota Storage Finish Download + * + * This function indicates to the storage module that the download has finished. + * + * @param offset The final offset of the downloaded file (i.e. the total size) + * Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageFinishDownloadCallback(uint32_t offset); +/** @brief Ota Storage Get Count + * + * This callback returns the total number of ZigBee Over-the-air upgrade images + * stored in the storage module. + * + */ +uint8_t emberAfOtaStorageGetCountCallback(void); +/** @brief Ota Storage Get Full Header + * + * This callback populates the EmberAfOtaHeader structure pointed to by the + * returnData with data about the OTA file stored in the storage module. + * + * @param id This is a pointer to the image id for the OTA file to retrieve + * information about. Ver.: always + * @param returnData This is a pointer to the location of the structure that + * will be populated with data. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageGetFullHeaderCallback(const EmberAfOtaImageId * id, EmberAfOtaHeader * returnData); +/** @brief Ota Storage Get Total Image Size + * + * This function returns the total size of the ZigBee Over-the-air file with the + * passed parameters. If no file is found with those parameters, 0 is returned. + * + * @param id A pointer to the image identifier for the OTA file to retrieve + * information for. Ver.: always + */ +uint32_t emberAfOtaStorageGetTotalImageSizeCallback(const EmberAfOtaImageId * id); +/** @brief Ota Storage Init + * + * This callback initializes the ZigBee Over-the-air storage module. + * + */ +EmberAfOtaStorageStatus emberAfOtaStorageInitCallback(void); +/** @brief Ota Storage Iterator First + * + * This callback lets you walk through the list of all OTA files by jumping to + * the first file in the list maintained by the storage module. If there is no + * file then emberAfOtaInvalidImageId is returned. + * + */ +EmberAfOtaImageId emberAfOtaStorageIteratorFirstCallback(void); +/** @brief Ota Storage Iterator Next + * + * This callback lets you walk through the list of all OTA files by jumping to + * the next file in the list maintained by the storage module. If there is no + * next file then emberAfOtaInvalidImageId is returned. + * + */ +EmberAfOtaImageId emberAfOtaStorageIteratorNextCallback(void); +/** @brief Ota Storage Read Image Data + * + * This callback reads data from the specified OTA file and returns that data to + * the caller. + * + * @param id This is a pointer to the image id for the OTA file to retrieve data + * from. Ver.: always + * @param offset This is the offset relative to the start of the image where the + * data should be read from. Ver.: always + * @param length This is the length of data that will be read. Ver.: always + * @param returnData This is a pointer to where the data read out of the file + * will be written to Ver.: always + * @param returnedLength This is a pointer to a variable where the actual length + * of data read will be written to. A short read may occur if the end of file + * was reached. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageReadImageDataCallback(const EmberAfOtaImageId * id, uint32_t offset, uint32_t length, + uint8_t * returnData, uint32_t * returnedLength); +/** @brief Ota Storage Search + * + * This callback searches through the list of all images for one that matches + * the passed parameters. On success an image identifier is returned with a + * matching image. On failure emberAfInvalidImageId is returned. + * + * @param manufacturerId The ZigBee assigned identifier of the manufacturer + * contained in the OTA image being searched for. Ver.: always + * @param imageTypeId The image type identifier contained in the OTA image being + * searched for. Ver.: always + * @param hardwareVersion This is a pointer to the hardware version that will be + * used in the search. If the pointer is NULL, hardware version will not be + * considered when searching for matching images. If it points to a value, the + * search will only consider images where that value falls between the minimum + * and maxmimum hardware version specified in the OTA file. If no hardware + * version is present in an OTA file but the other parameters match, the file + * will be considered a match Ver.: always + */ +EmberAfOtaImageId emberAfOtaStorageSearchCallback(uint16_t manufacturerId, uint16_t imageTypeId, const uint16_t * hardwareVersion); +/** @brief Ota Storage Write Temp Data + * + * This function writes to the temporary data in the storage device at the + * specified offset. It is used when downloading a raw image over the air. + * + * @param offset The location within the download image file where to write the + * data. Ver.: always + * @param length The length of data to write. Ver.: always + * @param data A pointer to the temporary data that will be written to the + * storage device. Ver.: always + */ +EmberAfOtaStorageStatus emberAfOtaStorageWriteTempDataCallback(uint32_t offset, uint32_t length, const uint8_t * data); +/** @brief Outgoing Packet Filter + * + * ** REQUIRES INCLUDING THE PACKET-HANDOFF PLUGIN ** + + This is called by + * the Packet Handoff plugin when the stack prepares to send a packet from one + * of the protocol layers specified in ::EmberZigbeePacketType. + + The + * packetType argument is one of the values of the ::EmberZigbeePacketType enum. + * If the stack receives an 802.15.4 MAC beacon, it will call this function with + * the packetType argument set to ::EMBER_ZIGBEE_PACKET_TYPE_BEACON. + + + * The implementation of this callback may alter the data contained in + * packetData, modify options and flags in the auxillary data, or consume the + * packet itself, either sending the message, or discarding it as it sees fit. + * + * @param packetType the type of packet and associated protocol layer Ver.: + * always + * @param packetData flat buffer containing the packet data associated with the + * packet type Ver.: always + * @param size_p a pointer containing the size value of the packet Ver.: always + * @param data auxillary data included with the packet Ver.: always + */ +EmberPacketAction emberAfOutgoingPacketFilterCallback(EmberZigbeePacketType packetType, uint8_t * packetData, uint8_t * size_p, + void * data); +/** @brief Partner Link Key Exchange Request + * + * This function is called by the framework on SOC platforms when a remote node + * requests a partner link key exchange. The application should return + * EMBER_SUCCESS to accept the request or any other status to reject it. On + * network coprocessor platforms, this function will not be called because the + * NCP handles partner link key exchange requests based on the binding policy. + * + * @param partner The EUI of the remote node. Ver.: always + */ +EmberZdoStatus emberAfPartnerLinkKeyExchangeRequestCallback(EmberEUI64 partner); +/** @brief Partner Link Key Exchange Response + * + * This function is called by the framework when a remote node requests a + * partner link key exchange. The application should return true to accept the + * request or false to reject it. On network coprocessor platforms, this + * function will not be called because the NCP handles partner link key exchange + * requests based on the binding policy. + * + * @param sender The EUI of the remote node. Ver.: always + * @param status The ZDO response status. Ver.: always + */ +void emberAfPartnerLinkKeyExchangeResponseCallback(EmberNodeId sender, EmberZdoStatus status); +/** @brief Performing Key Establishment + * + * This function is called by the framework to determine if the device is + * performing key establishment. The application should return true if key + * establishment is in progress. + * + */ +bool emberAfPerformingKeyEstablishmentCallback(void); +/** @brief Post Attribute Change + * + * This function is called by the application framework after it changes an + * attribute value. The value passed into this callback is the value to which + * the attribute was set by the framework. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param type Ver.: always + * @param size Ver.: always + * @param value Ver.: always + */ +void emberAfPostAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, uint8_t mask, + uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value); +/** @brief Post Em4 Reset + * + * A callback called by application framework, and implemented by em4 plugin + * + */ +void emberAfPostEm4ResetCallback(void); +/** @brief Pre Attribute Change + * + * This function is called by the application framework before it changes an + * attribute value. The value passed into this callback is the value to which + * the attribute is to be set by the framework. The application should return + * ::EMBER_ZCL_STATUS_SUCCESS to permit the change or any other ::EmberAfStatus + * to reject it. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param type Ver.: always + * @param size Ver.: always + * @param value Ver.: always + */ +EmberAfStatus emberAfPreAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, + uint8_t * value); +/** @brief Pre Cli Send + * + * This function is called by the framework when it is about to pass a message + * constructed over CLI to the stack primitives for sending. If the function + * returns true it is assumed that the callback has consumed and processed the + * message. The framework will not do any further processing on the message. + + * If the function returns false then it is assumed that the callback has + * not processed the message and the framework will continue to process + * accordingly. + * + * @param apsFrame The structure containing the APS frame Ver.: always + * @param source Source Node Id Ver.: always + * @param destination Destintion Node Id Ver.: always + * @param message Pointer to the message payload Ver.: always + * @param messageLength Length of the message payload Ver.: always + */ +bool emberAfPreCliSendCallback(EmberApsFrame * apsFrame, EmberNodeId source, EmberNodeId destination, uint8_t * message, + uint16_t messageLength); +/** @brief Pre Command Received + * + * This callback is the second in the Application Framework's message processing + * chain. At this point in the processing of incoming over-the-air messages, the + * application has determined that the incoming message is a ZCL command. It + * parses enough of the message to populate an EmberAfClusterCommand struct. The + * Application Framework defines this struct value in a local scope to the + * command processing but also makes it available through a global pointer + * called emberAfCurrentCommand, in app/framework/util/util.c. When command + * processing is complete, this pointer is cleared. + * + * @param cmd Ver.: always + */ +bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand * cmd); +/** @brief Pre Message Received + * + * This callback is the first in the Application Framework's message processing + * chain. The Application Framework calls it when a message has been received + * over the air but has not yet been parsed by the ZCL command-handling code. If + * you wish to parse some messages that are completely outside the ZCL + * specification or are not handled by the Application Framework's command + * handling code, you should intercept them for parsing in this callback. + + * This callback returns a Boolean value indicating whether or not the message + * has been handled. If the callback returns a value of true, then the + * Application Framework assumes that the message has been handled and it does + * nothing else with it. If the callback returns a value of false, then the + * application framework continues to process the message as it would with any + * incoming message. + Note: This callback receives a pointer to an + * incoming message struct. This struct allows the application framework to + * provide a unified interface between both Host devices, which receive their + * message through the ezspIncomingMessageHandler, and SoC devices, which + * receive their message through emberIncomingMessageHandler. + * + * @param incomingMessage Ver.: always + */ +bool emberAfPreMessageReceivedCallback(EmberAfIncomingMessage * incomingMessage); +/** @brief Pre Message Send + * + * This function is called by the framework when it is about to pass a message + * to the stack primitives for sending. This message may or may not be ZCL, + * ZDO, or some other protocol. This is called prior to + any ZigBee + * fragmentation that may be done. If the function returns true it is assumed + * the callback has consumed and processed the message. The callback must also + * set the EmberStatus status code to be passed back to the caller. The + * framework will do no further processing on the message. + If the + * function returns false then it is assumed that the callback has not processed + * the mesasge and the framework will continue to process accordingly. + * + * @param messageStruct The structure containing the parameters of the APS + * message to be sent. Ver.: always + * @param status A pointer to the status code value that will be returned to the + * caller. Ver.: always + */ +bool emberAfPreMessageSendCallback(EmberAfMessageStruct * messageStruct, EmberStatus * status); +/** @brief Pre Ncp Reset + * + * This function will be called prior to the reset of the NCP by the host. + * + */ +void emberAfPreNcpResetCallback(void); +/** @brief Pre ZDO Message Received + * + * This function passes the application an incoming ZDO message and gives the + * appictation the opportunity to handle it. By default, this callback returns + * false indicating that the incoming ZDO message has not been handled and + * should be handled by the Application Framework. + * + * @param emberNodeId Ver.: always + * @param apsFrame Ver.: always + * @param message Ver.: always + * @param length Ver.: always + */ +bool emberAfPreZDOMessageReceivedCallback(EmberNodeId emberNodeId, EmberApsFrame * apsFrame, uint8_t * message, uint16_t length); +/** @brief Read Attributes Response + * + * This function is called by the application framework when a Read Attributes + * Response command is received from an external device. The application should + * return true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of read attribute status records. + * Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfReadAttributesResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); +/** @brief Read Reporting Configuration Command + * + * This function is called by the application framework when a Read Reporting + * Configuration command is received from an external device. The application + * should return true if the message was processed or false if it was not. + * + * @param cmd Ver.: always + */ +bool emberAfReadReportingConfigurationCommandCallback(const EmberAfClusterCommand * cmd); +/** @brief Read Reporting Configuration Response + * + * This function is called by the application framework when a Read Reporting + * Configuration Response command is received from an external device. The + * application should return true if the message was processed or false if it + * was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of attribute reporting configuration + * records. Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfReadReportingConfigurationResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); +/** @brief Registration Abort + * + * This callback is called when the device should abort the registration + * process. + * + */ +void emberAfRegistrationAbortCallback(void); +/** @brief Registration + * + * This callback is called when the device joins a network and the process of + * registration is complete. This callback provides a success value of true if + * the registration process was successful and a value of false if registration + * failed. + * + * @param success true if registration succeeded, false otherwise. Ver.: always + */ +void emberAfRegistrationCallback(bool success); +/** @brief Registration Start + * + * This callback is called when the device joins a network and the registration + * process should begin. The application should return EMBER_SUCCESS if the + * registration process started successfully. When registration is complete, + * the application should call emberAfRegistrationCallback with an indication of + * success or failure. + * + */ +EmberStatus emberAfRegistrationStartCallback(void); +/** @brief Remote Delete Binding Permission + * + * This function is called by the framework to request permission to service the + * remote delete binding request. Return EMBER_SUCCESS to allow request, + * anything else to disallow request. + * + * @param index index to an Ember binding table entry Ver.: always + */ +EmberStatus emberAfRemoteDeleteBindingPermissionCallback(uint8_t index); +/** @brief Remote Set Binding Permission + * + * This function is called by the framework to request permission to service the + * remote set binding request. Return EMBER_SUCCESS to allow request, anything + * else to disallow request. + * + * @param entry Ember Binding Tablet Entry Ver.: always + */ +EmberStatus emberAfRemoteSetBindingPermissionCallback(const EmberBindingTableEntry * entry); +/** @brief Remove From Current App Tasks + * + * This function is only useful to sleepy end devices. This function will + * remove the passed item from the set of tasks the application has outstanding + * (e.g. message sent requiring APS acknwoledgement). This will affect how the + * application behaves with regard to sleeping and polling. Removing the item + * from the list of outstanding tasks may allow the device to sleep longer and + * poll less frequently. If there are other outstanding tasks the system may + * still have to stay away and poll more often. + * + * @param tasks Ver.: always + */ +void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks); +/** @brief Report Attributes + * + * This function is called by the application framework when a Report Attributes + * command is received from an external device. The application should return + * true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this command. Ver.: always + * @param buffer Buffer containing the list of attribute report records. Ver.: + * always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfReportAttributesCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); +/** @brief Reporting Attribute Change + * + * This function is called by the framework when an attribute managed by the + * framework changes. The application should call this function when an + * externally-managed attribute changes. The application should use the change + * notification to inform its reporting decisions. + * + * @param endpoint Ver.: always + * @param clusterId Ver.: always + * @param attributeId Ver.: always + * @param mask Ver.: always + * @param manufacturerCode Ver.: always + * @param type Ver.: always + * @param data Ver.: always + */ +void emberAfReportingAttributeChangeCallback(uint8_t endpoint, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t mask, uint16_t manufacturerCode, EmberAfAttributeType type, uint8_t * data); +/** @brief Scan Complete + * + * This is called by the low-level stack code when an 802.15.4 active scan + * completes. + * + * @param channel If the status indicates an error, the channel on which the + * error occurred. Otherwise it is undefined for EMBER_SUCCESS. Ver.: always + * @param status The status of the scan. Ver.: always + */ +void emberAfScanCompleteCallback(uint8_t channel, EmberStatus status); +/** @brief Scan Error + * + * This is called by the framework on behalf of the form-and-join library to + * notify the application if an error occurs while scanning. See form-and-join + * documentation for more information. + * + * @param status The status of the scan. Ver.: always + */ +void emberAfScanErrorCallback(EmberStatus status); +/** @brief Security Init + * + * This callback is called by the framework to give the application a chance to + * modify the security settings of the node during network initialization. + * Depending on the context when this callback is called, the pointer to the + * initial security state may be NULL, which means the initial security state + * can no longer be modified as the node is already operating on the network. + * + * @param state Ver.: always + * @param extended Ver.: always + * @param trustCenter Ver.: always + */ +void emberAfSecurityInitCallback(EmberInitialSecurityState * state, EmberExtendedSecurityBitmask * extended, bool trustCenter); +/** @brief Set Default Poll Control + * + * This function will set the default poll control for the current network to + * control whether or not it can long poll. + * + * @param control Ver.: always + */ +void emberAfSetDefaultPollControlCallback(EmberAfEventPollControl control); +/** @brief Set Default Sleep Control + * + * This function will set the default behavior of a sleeping device to control + * whether or not it must stay awake. A device that stays awake does not sleep + * at all. Otherwise, the device can sleep between events when appropriate. + * + * @param control Ver.: always + */ +void emberAfSetDefaultSleepControlCallback(EmberAfEventSleepControl control); +/** @brief Set Form And Join Extended Pan Id + * + * This callback is called by the framework to set the extended PAN ID used by + * the current network for forming and joining. The extended PAN ID used for + * forming and joining is not necessarily the same extended PAN ID actually in + * use on the network. + * + * @param extendedPanId Ver.: always + */ +void emberAfSetFormAndJoinExtendedPanIdCallback(const uint8_t * extendedPanId); +/** @brief Set Long Poll Interval Ms + * + * This function is only useful to end devices. This function will set the long + * poll interval (in milliseconds) for the current network. This interval is + * the maximum amount of time a child will wait between polls of its parent when + * it is not expecting data. + * + * @param longPollIntervalMs Ver.: always + */ +void emberAfSetLongPollIntervalMsCallback(uint32_t longPollIntervalMs); +/** @brief Set Long Poll Interval Qs + * + * This function is only useful to end devices. This function will set the long + * poll interval (in quarter seconds) for the current network. This interval is + * the maximum amount of time a child will wait between polls of its parent when + * it is not expecting data. + * + * @param longPollIntervalQs Ver.: always + */ +void emberAfSetLongPollIntervalQsCallback(uint32_t longPollIntervalQs); +/** @brief Set Short Poll Interval Ms + * + * This function is only useful to sleepy end devices. This function will set + * the short poll interval (in milliseconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is expecting data. + * + * @param shortPollIntervalMs Ver.: always + */ +void emberAfSetShortPollIntervalMsCallback(uint16_t shortPollIntervalMs); +/** @brief Set Short Poll Interval Qs + * + * This function is only useful to sleepy end devices. This function will set + * the short poll interval (in quarter seconds) for the current network. This + * interval is the maximum amount of time a child will wait between polls of its + * parent when it is expecting data. + * + * @param shortPollIntervalQs Ver.: always + */ +void emberAfSetShortPollIntervalQsCallback(uint16_t shortPollIntervalQs); +/** @brief Set Source Route Overhead + * + * This function is called by the framework when it has information about the + * source route overhead to a particular destination. The application may use + * this information to cache the source route overhead. + * + * @param destination The node id of the destination Ver.: always + * @param overhead The overhead in bytes Ver.: always + */ +void emberAfSetSourceRouteOverheadCallback(EmberNodeId destination, uint8_t overhead); +/** @brief Set Time + * + * This callback should be implemented, if the device has access to real time + * clock, and has an ability to update that clock. The application framework + * expects to be passed the utcTime which is the number of seconds since the + * year 2000. Default implementation does nothing. Note: This function used to + * take time in year, month, day, hour, min, sec. We have changed this to + * utcTime in order to conserve code space. + * + * @param utcTime Ver.: always + */ +void emberAfSetTimeCallback(uint32_t utcTime); +/** @brief Set Wake Timeout Bitmask + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout bitmask for the current network. The bitmask determines + * which tasks will timeout automatically and which tasks require manual removal + * from the task list. + * + * @param tasks Ver.: always + */ +void emberAfSetWakeTimeoutBitmaskCallback(EmberAfApplicationTask tasks); +/** @brief Set Wake Timeout Ms + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout (in milliseconds) for the current network. This timeout is + * the maximum amount of time a child will wait for a task in the wake bitmask + * to finish. While waiting, the device will short poll. + * + * @param wakeTimeoutMs Ver.: always + */ +void emberAfSetWakeTimeoutMsCallback(uint16_t wakeTimeoutMs); +/** @brief Set Wake Timeout Qs + * + * This function is only useful to sleepy end devices. This function will set + * the wake timeout (in quarter seconds) for the current network. This timeout + * is the maximum amount of time a child will wait for a task in the wake + * bitmask to finish. While waiting, the device will short poll. + * + * @param wakeTimeoutQs Ver.: always + */ +void emberAfSetWakeTimeoutQsCallback(uint16_t wakeTimeoutQs); +/** @brief Stack Status + * + * This function is called by the application framework from the stack status + * handler. This callbacks provides applications an opportunity to be notified + * of changes to the stack status and take appropriate action. The return code + * from this callback is ignored by the framework. The framework will always + * process the stack status after the callback returns. + * + * @param status Ver.: always + */ +bool emberAfStackStatusCallback(EmberStatus status); +/** @brief Start Move + * + * This function is called to initiate the process for a device to move (rejoin) + * to a new parent. + * + */ +bool emberAfStartMoveCallback(void); +/** @brief Start Search For Joinable Network + * + * This function is called by the framework to search for joinable networks and + * join a network. The application should return EMBER_SUCCESS if the operation + * was initiated successfully. + * + */ +EmberStatus emberAfStartSearchForJoinableNetworkCallback(void); +/** @brief Stop Move + * + * This function is called to cancel a previously scheduled move (rejoin) to a + * new parent. + * + */ +void emberAfStopMoveCallback(void); +/** @brief Trust Center Join + * + * This callback is called from within the application framework's + * implementation of emberTrustCenterJoinHandler or ezspTrustCenterJoinHandler. + * This callback provides the same arguments passed to the + * TrustCenterJoinHandler. For more information about the TrustCenterJoinHandler + * please see documentation included in stack/include/trust-center.h. + * + * @param newNodeId Ver.: always + * @param newNodeEui64 Ver.: always + * @param parentOfNewNode Ver.: always + * @param status Ver.: always + * @param decision Ver.: always + */ +void emberAfTrustCenterJoinCallback(EmberNodeId newNodeId, EmberEUI64 newNodeEui64, EmberNodeId parentOfNewNode, + EmberDeviceUpdate status, EmberJoinDecision decision); +/** @brief Trust Center Keepalive Abort + * + * This callback is called when the device should abort the trust center + * keepalive process. + * + */ +void emberAfTrustCenterKeepaliveAbortCallback(void); +/** @brief Trust Center Keepalive Update + * + * This callback is called when the device finishes registration (successfully + * or otherwise) and the trust center keepalive process must be updated. If the + * keepalive process has not been started, then it is started. Otherwise if the + * keepalive is in the process of searching for the TC, it will process the + * result of that Trust Center search operation. + * + * @param registrationComplete Ver.: always + */ +void emberAfTrustCenterKeepaliveUpdateCallback(bool registrationComplete); +/** @brief Unused Pan Id Found + * + * This is called by the framework on behalf of the form-and-join library to + * notify the application of the PAN id and channel found following a call to + * ::emberScanForUnusedPanId(). See form-and-join documentation for more + * information. + * + * @param panId Ver.: always + * @param channel Ver.: always + */ +void emberAfUnusedPanIdFoundCallback(EmberPanId panId, uint8_t channel); +/** @brief Write Attributes Response + * + * This function is called by the application framework when a Write Attributes + * Response command is received from an external device. The application should + * return true if the message was processed or false if it was not. + * + * @param clusterId The cluster identifier of this response. Ver.: always + * @param buffer Buffer containing the list of write attribute status records. + * Ver.: always + * @param bufLen The length in bytes of the list. Ver.: always + */ +bool emberAfWriteAttributesResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen); +/** @brief Zigbee Key Establishment + * + * A callback to the application to notify it of the status of the request for a + * Link Key. + * + * @param partner partner The IEEE address of the partner device. Or all zeros + * if the Key establishment failed. Ver.: always + * @param status The status of the key establishment. Ver.: always + */ +void emberAfZigbeeKeyEstablishmentCallback(EmberEUI64 partner, EmberKeyStatus status); +/** @} END Non-Cluster Related Callbacks */ + +/** @name Basic Cluster Callbacks */ +// @{ + +/** @brief Basic Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBasicClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Basic Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBasicClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Basic Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBasicClusterClientInitCallback(uint8_t endpoint); +/** @brief Basic Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBasicClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Basic Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Basic Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBasicClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Basic Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBasicClusterClientTickCallback(uint8_t endpoint); +/** @brief Basic Cluster Get Locales Supported + * + * + * + * @param startLocale Ver.: always + * @param maxLocalesRequested Ver.: always + */ +bool emberAfBasicClusterGetLocalesSupportedCallback(uint8_t * startLocale, uint8_t maxLocalesRequested); +/** @brief Basic Cluster Get Locales Supported Response + * + * + * + * @param discoveryComplete Ver.: always + * @param localeSupported Ver.: always + */ +bool emberAfBasicClusterGetLocalesSupportedResponseCallback(uint8_t discoveryComplete, uint8_t * localeSupported); +/** @brief Basic Cluster Reset To Factory Defaults + * + * + * + */ +bool emberAfBasicClusterResetToFactoryDefaultsCallback(void); +/** @brief Basic Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBasicClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Basic Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBasicClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Basic Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBasicClusterServerInitCallback(uint8_t endpoint); +/** @brief Basic Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBasicClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Basic Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Basic Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBasicClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Basic Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBasicClusterServerTickCallback(uint8_t endpoint); + +/** @} END Basic Cluster Callbacks */ + +/** @name Power Configuration Cluster Callbacks */ +// @{ + +/** @brief Power Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPowerConfigClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Power Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPowerConfigClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Power Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPowerConfigClusterClientInitCallback(uint8_t endpoint); +/** @brief Power Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPowerConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Power Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPowerConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Power Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPowerConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Power Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPowerConfigClusterClientTickCallback(uint8_t endpoint); +/** @brief Power Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPowerConfigClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Power Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPowerConfigClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Power Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPowerConfigClusterServerInitCallback(uint8_t endpoint); +/** @brief Power Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPowerConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Power Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPowerConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Power Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPowerConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Power Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPowerConfigClusterServerTickCallback(uint8_t endpoint); + +/** @} END Power Configuration Cluster Callbacks */ + +/** @name Device Temperature Configuration Cluster Callbacks */ +// @{ + +/** @brief Device Temperature Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDeviceTempClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Device Temperature Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDeviceTempClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Device Temperature Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDeviceTempClusterClientInitCallback(uint8_t endpoint); +/** @brief Device Temperature Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDeviceTempClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Device Temperature Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDeviceTempClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Device Temperature Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDeviceTempClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Device Temperature Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDeviceTempClusterClientTickCallback(uint8_t endpoint); +/** @brief Device Temperature Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDeviceTempClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Device Temperature Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDeviceTempClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Device Temperature Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDeviceTempClusterServerInitCallback(uint8_t endpoint); +/** @brief Device Temperature Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDeviceTempClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Device Temperature Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDeviceTempClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Device Temperature Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDeviceTempClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Device Temperature Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDeviceTempClusterServerTickCallback(uint8_t endpoint); + +/** @} END Device Temperature Configuration Cluster Callbacks */ + +/** @name Identify Cluster Callbacks */ +// @{ + +/** @brief Identify Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIdentifyClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Identify Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIdentifyClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Identify Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIdentifyClusterClientInitCallback(uint8_t endpoint); +/** @brief Identify Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIdentifyClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Identify Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIdentifyClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Identify Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIdentifyClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Identify Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIdentifyClusterClientTickCallback(uint8_t endpoint); +/** @brief Identify Cluster E Z Mode Invoke + * + * + * + * @param action Ver.: always + */ +bool emberAfIdentifyClusterEZModeInvokeCallback(uint8_t action); +/** @brief Identify Cluster Identify + * + * + * + * @param identifyTime Ver.: always + */ +bool emberAfIdentifyClusterIdentifyCallback(uint16_t identifyTime); +/** @brief Identify Cluster Identify Query + * + * + * + */ +bool emberAfIdentifyClusterIdentifyQueryCallback(void); +/** @brief Identify Cluster Identify Query Response + * + * + * + * @param timeout Ver.: always + */ +bool emberAfIdentifyClusterIdentifyQueryResponseCallback(uint16_t timeout); +/** @brief Identify Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIdentifyClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Identify Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIdentifyClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Identify Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIdentifyClusterServerInitCallback(uint8_t endpoint); +/** @brief Identify Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIdentifyClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Identify Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIdentifyClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Identify Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIdentifyClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Identify Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIdentifyClusterServerTickCallback(uint8_t endpoint); +/** @brief Identify Cluster Trigger Effect + * + * + * + * @param effectId Ver.: always + * @param effectVariant Ver.: always + */ +bool emberAfIdentifyClusterTriggerEffectCallback(uint8_t effectId, uint8_t effectVariant); +/** @brief Identify Cluster Update Commission State + * + * + * + * @param action Ver.: always + * @param commissionStateMask Ver.: always + */ +bool emberAfIdentifyClusterUpdateCommissionStateCallback(uint8_t action, uint8_t commissionStateMask); + +/** @} END Identify Cluster Callbacks */ + +/** @name Groups Cluster Callbacks */ +// @{ + +/** @brief Groups Cluster Clear Group Table + * + * This function is called by the framework when the application should clear + * the group table. + * + * @param endpoint The endpoint. Ver.: always + */ +void emberAfGroupsClusterClearGroupTableCallback(uint8_t endpoint); +/** @brief Groups Cluster Endpoint In Group + * + * This function is called by the framework when it needs to determine if an + * endpoint is a member of a group. The application should return true if the + * endpoint is a member of the group and false otherwise. + * + * @param endpoint The endpoint. Ver.: always + * @param groupId The group identifier. Ver.: always + */ +bool emberAfGroupsClusterEndpointInGroupCallback(uint8_t endpoint, uint16_t groupId); +/** @brief Groups Cluster Add Group + * + * + * + * @param groupId Ver.: always + * @param groupName Ver.: always + */ +bool emberAfGroupsClusterAddGroupCallback(uint16_t groupId, uint8_t * groupName); +/** @brief Groups Cluster Add Group If Identifying + * + * + * + * @param groupId Ver.: always + * @param groupName Ver.: always + */ +bool emberAfGroupsClusterAddGroupIfIdentifyingCallback(uint16_t groupId, uint8_t * groupName); +/** @brief Groups Cluster Add Group Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + */ +bool emberAfGroupsClusterAddGroupResponseCallback(uint8_t status, uint16_t groupId); +/** @brief Groups Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGroupsClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Groups Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGroupsClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Groups Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGroupsClusterClientInitCallback(uint8_t endpoint); +/** @brief Groups Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGroupsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Groups Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGroupsClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Groups Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGroupsClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Groups Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGroupsClusterClientTickCallback(uint8_t endpoint); +/** @brief Groups Cluster Get Group Membership + * + * + * + * @param groupCount Ver.: always + * @param groupList Ver.: always + */ +bool emberAfGroupsClusterGetGroupMembershipCallback(uint8_t groupCount, uint8_t * groupList); +/** @brief Groups Cluster Get Group Membership Response + * + * + * + * @param capacity Ver.: always + * @param groupCount Ver.: always + * @param groupList Ver.: always + */ +bool emberAfGroupsClusterGetGroupMembershipResponseCallback(uint8_t capacity, uint8_t groupCount, uint8_t * groupList); +/** @brief Groups Cluster Remove All Groups + * + * + * + */ +bool emberAfGroupsClusterRemoveAllGroupsCallback(void); +/** @brief Groups Cluster Remove Group + * + * + * + * @param groupId Ver.: always + */ +bool emberAfGroupsClusterRemoveGroupCallback(uint16_t groupId); +/** @brief Groups Cluster Remove Group Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + */ +bool emberAfGroupsClusterRemoveGroupResponseCallback(uint8_t status, uint16_t groupId); +/** @brief Groups Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGroupsClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Groups Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGroupsClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Groups Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGroupsClusterServerInitCallback(uint8_t endpoint); +/** @brief Groups Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGroupsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Groups Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGroupsClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Groups Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGroupsClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Groups Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGroupsClusterServerTickCallback(uint8_t endpoint); +/** @brief Groups Cluster View Group + * + * + * + * @param groupId Ver.: always + */ +bool emberAfGroupsClusterViewGroupCallback(uint16_t groupId); +/** @brief Groups Cluster View Group Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param groupName Ver.: always + */ +bool emberAfGroupsClusterViewGroupResponseCallback(uint8_t status, uint16_t groupId, uint8_t * groupName); + +/** @} END Groups Cluster Callbacks */ + +/** @name Scenes Cluster Callbacks */ +// @{ + +/** @brief Scenes Cluster ClearSceneTable + * + * This function is called by the framework when the application should clear + * the scene table. + * + * @param endpoint The endpoint. Ver.: always + */ +void emberAfScenesClusterClearSceneTableCallback(uint8_t endpoint); +/** @brief Scenes Cluster Make Invalid + * + * This function is called to invalidate the valid attribute in the Scenes + * cluster. + * + * @param endpoint Ver.: always + */ +EmberAfStatus emberAfScenesClusterMakeInvalidCallback(uint8_t endpoint); +/** @brief Scenes Cluster Recall Saved Scene + * + * This function is called by the framework when the application should recall a + * saved scene. + * + * @param endpoint The endpoint. Ver.: always + * @param groupId The group identifier. Ver.: always + * @param sceneId The scene identifier. Ver.: always + */ +EmberAfStatus emberAfScenesClusterRecallSavedSceneCallback(uint8_t endpoint, uint16_t groupId, uint8_t sceneId); +/** @brief Scenes Cluster Remove Scenes In Group + * + * This function removes the scenes from a specified group. + * + * @param endpoint Endpoint Ver.: always + * @param groupId Group ID Ver.: always + */ +void emberAfScenesClusterRemoveScenesInGroupCallback(uint8_t endpoint, uint16_t groupId); +/** @brief Scenes Cluster Add Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + * @param transitionTime Ver.: always + * @param sceneName Ver.: always + * @param extensionFieldSets Ver.: always + */ +bool emberAfScenesClusterAddSceneCallback(uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, uint8_t * sceneName, + uint8_t * extensionFieldSets); +/** @brief Scenes Cluster Add Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterAddSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId); +/** @brief Scenes Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfScenesClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Scenes Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfScenesClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Scenes Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfScenesClusterClientInitCallback(uint8_t endpoint); +/** @brief Scenes Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfScenesClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Scenes Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfScenesClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Scenes Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfScenesClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Scenes Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfScenesClusterClientTickCallback(uint8_t endpoint); +/** @brief Scenes Cluster Copy Scene + * + * + * + * @param mode Ver.: always + * @param groupIdFrom Ver.: always + * @param sceneIdFrom Ver.: always + * @param groupIdTo Ver.: always + * @param sceneIdTo Ver.: always + */ +bool emberAfScenesClusterCopySceneCallback(uint8_t mode, uint16_t groupIdFrom, uint8_t sceneIdFrom, uint16_t groupIdTo, + uint8_t sceneIdTo); +/** @brief Scenes Cluster Copy Scene Response + * + * + * + * @param status Ver.: always + * @param groupIdFrom Ver.: always + * @param sceneIdFrom Ver.: always + */ +bool emberAfScenesClusterCopySceneResponseCallback(uint8_t status, uint16_t groupIdFrom, uint8_t sceneIdFrom); +/** @brief Scenes Cluster Enhanced Add Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + * @param transitionTime Ver.: always + * @param sceneName Ver.: always + * @param extensionFieldSets Ver.: always + */ +bool emberAfScenesClusterEnhancedAddSceneCallback(uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, uint8_t * sceneName, + uint8_t * extensionFieldSets); +/** @brief Scenes Cluster Enhanced Add Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterEnhancedAddSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId); +/** @brief Scenes Cluster Enhanced View Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterEnhancedViewSceneCallback(uint16_t groupId, uint8_t sceneId); +/** @brief Scenes Cluster Enhanced View Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + * @param transitionTime Ver.: always + * @param sceneName Ver.: always + * @param extensionFieldSets Ver.: always + */ +bool emberAfScenesClusterEnhancedViewSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId, + uint16_t transitionTime, uint8_t * sceneName, + uint8_t * extensionFieldSets); +/** @brief Scenes Cluster Get Scene Membership + * + * + * + * @param groupId Ver.: always + */ +bool emberAfScenesClusterGetSceneMembershipCallback(uint16_t groupId); +/** @brief Scenes Cluster Get Scene Membership Response + * + * + * + * @param status Ver.: always + * @param capacity Ver.: always + * @param groupId Ver.: always + * @param sceneCount Ver.: always + * @param sceneList Ver.: always + */ +bool emberAfScenesClusterGetSceneMembershipResponseCallback(uint8_t status, uint8_t capacity, uint16_t groupId, uint8_t sceneCount, + uint8_t * sceneList); +/** @brief Scenes Cluster Recall Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + * @param transitionTime Ver.: since zcl-7.0-07-5123-07 + */ +bool emberAfScenesClusterRecallSceneCallback(uint16_t groupId, uint8_t sceneId, uint16_t transitionTime); +/** @brief Scenes Cluster Remove All Scenes + * + * + * + * @param groupId Ver.: always + */ +bool emberAfScenesClusterRemoveAllScenesCallback(uint16_t groupId); +/** @brief Scenes Cluster Remove All Scenes Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + */ +bool emberAfScenesClusterRemoveAllScenesResponseCallback(uint8_t status, uint16_t groupId); +/** @brief Scenes Cluster Remove Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterRemoveSceneCallback(uint16_t groupId, uint8_t sceneId); +/** @brief Scenes Cluster Remove Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterRemoveSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId); +/** @brief Scenes Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfScenesClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Scenes Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfScenesClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Scenes Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfScenesClusterServerInitCallback(uint8_t endpoint); +/** @brief Scenes Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfScenesClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Scenes Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfScenesClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Scenes Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfScenesClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Scenes Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfScenesClusterServerTickCallback(uint8_t endpoint); +/** @brief Scenes Cluster Store Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterStoreSceneCallback(uint16_t groupId, uint8_t sceneId); +/** @brief Scenes Cluster Store Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterStoreSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId); +/** @brief Scenes Cluster View Scene + * + * + * + * @param groupId Ver.: always + * @param sceneId Ver.: always + */ +bool emberAfScenesClusterViewSceneCallback(uint16_t groupId, uint8_t sceneId); +/** @brief Scenes Cluster View Scene Response + * + * + * + * @param status Ver.: always + * @param groupId Ver.: always + * @param sceneId Ver.: always + * @param transitionTime Ver.: always + * @param sceneName Ver.: always + * @param extensionFieldSets Ver.: always + */ +bool emberAfScenesClusterViewSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, + uint8_t * sceneName, uint8_t * extensionFieldSets); +/** @brief Scenes Cluster Store Current Scene + * + * This function is called by the framework when the application should store + * the current scene. If an entry already exists in the scene table with the + * same scene and group ids, the application should update the entry with the + * current scene. Otherwise, a new entry should be adde to the scene table, if + * possible. + * + * @param endpoint The endpoint. Ver.: always + * @param groupId The group identifier. Ver.: always + * @param sceneId The scene identifier. Ver.: always + */ +EmberAfStatus emberAfScenesClusterStoreCurrentSceneCallback(uint8_t endpoint, uint16_t groupId, uint8_t sceneId); + +/** @} END Scenes Cluster Callbacks */ + +/** @name On/off Cluster Callbacks */ +// @{ + +/** @brief On/off Cluster Level Control Effect + * + * This is called by the framework when the on/off cluster initiates a command + * that must effect a level control change. The implementation assumes that the + * client will handle any effect on the On/Off Cluster. + * + * @param endpoint Ver.: always + * @param newValue Ver.: always + */ +void emberAfOnOffClusterLevelControlEffectCallback(uint8_t endpoint, bool newValue); +/** @brief On/off Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOnOffClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief On/off Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOnOffClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief On/off Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOnOffClusterClientInitCallback(uint8_t endpoint); +/** @brief On/off Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOnOffClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief On/off Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOnOffClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief On/off Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOnOffClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief On/off Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOnOffClusterClientTickCallback(uint8_t endpoint); +/** @brief On/off Cluster Off + * + * + * + */ +bool emberAfOnOffClusterOffCallback(void); +/** @brief On/off Cluster Off With Effect + * + * + * + * @param effectId Ver.: always + * @param effectVariant Ver.: always + */ +bool emberAfOnOffClusterOffWithEffectCallback(uint8_t effectId, uint8_t effectVariant); +/** @brief On/off Cluster On + * + * + * + */ +bool emberAfOnOffClusterOnCallback(void); +/** @brief On/off Cluster On With Recall Global Scene + * + * + * + */ +bool emberAfOnOffClusterOnWithRecallGlobalSceneCallback(void); +/** @brief On/off Cluster On With Timed Off + * + * + * + * @param onOffControl Ver.: always + * @param onTime Ver.: always + * @param offWaitTime Ver.: always + */ +bool emberAfOnOffClusterOnWithTimedOffCallback(uint8_t onOffControl, uint16_t onTime, uint16_t offWaitTime); +/** @brief On/off Cluster Sample Mfg Specific Off With Transition + * + * + * + */ +bool emberAfOnOffClusterSampleMfgSpecificOffWithTransitionCallback(void); +/** @brief On/off Cluster Sample Mfg Specific On With Transition2 + * + * + * + */ +bool emberAfOnOffClusterSampleMfgSpecificOnWithTransition2Callback(void); +/** @brief On/off Cluster Sample Mfg Specific On With Transition + * + * + * + */ +bool emberAfOnOffClusterSampleMfgSpecificOnWithTransitionCallback(void); +/** @brief On/off Cluster Sample Mfg Specific Toggle With Transition2 + * + * + * + */ +bool emberAfOnOffClusterSampleMfgSpecificToggleWithTransition2Callback(void); +/** @brief On/off Cluster Sample Mfg Specific Toggle With Transition + * + * + * + */ +bool emberAfOnOffClusterSampleMfgSpecificToggleWithTransitionCallback(void); +/** @brief On/off Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOnOffClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief On/off Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOnOffClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief On/off Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOnOffClusterServerInitCallback(uint8_t endpoint); +/** @brief On/off Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOnOffClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief On/off Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOnOffClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief On/off Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOnOffClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief On/off Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOnOffClusterServerTickCallback(uint8_t endpoint); +/** @brief On/off Cluster Toggle + * + * + * + */ +bool emberAfOnOffClusterToggleCallback(void); +/** @brief On/off Cluster Set Value + * + * This function is called when the on/off value needs to be set, either through + * normal channels or as a result of a level change. + * + * @param endpoint Ver.: always + * @param command Ver.: always + * @param initiatedByLevelChange Ver.: always + */ +EmberAfStatus emberAfOnOffClusterSetValueCallback(uint8_t endpoint, uint8_t command, bool initiatedByLevelChange); + +/** @} END On/off Cluster Callbacks */ + +/** @name On/off Switch Configuration Cluster Callbacks */ +// @{ + +/** @brief On/off Switch Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief On/off Switch Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief On/off Switch Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientInitCallback(uint8_t endpoint); +/** @brief On/off Switch Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief On/off Switch Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief On/off Switch Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOnOffSwitchConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief On/off Switch Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOnOffSwitchConfigClusterClientTickCallback(uint8_t endpoint); +/** @brief On/off Switch Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief On/off Switch Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief On/off Switch Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerInitCallback(uint8_t endpoint); +/** @brief On/off Switch Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief On/off Switch Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief On/off Switch Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOnOffSwitchConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief On/off Switch Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOnOffSwitchConfigClusterServerTickCallback(uint8_t endpoint); + +/** @} END On/off Switch Configuration Cluster Callbacks */ + +/** @name Level Control Cluster Callbacks */ +// @{ + +/** @brief Level Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfLevelControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Level Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfLevelControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Level Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfLevelControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Level Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfLevelControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Level Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfLevelControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Level Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfLevelControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Level Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfLevelControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Level Control Cluster Move + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + * @param optionMask Ver.: since zcl6-errata-14-0129-15 + * @param optionOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfLevelControlClusterMoveCallback(uint8_t moveMode, uint8_t rate, uint8_t optionMask, uint8_t optionOverride); +/** @brief Level Control Cluster Move To Level + * + * + * + * @param level Ver.: always + * @param transitionTime Ver.: always + * @param optionMask Ver.: since zcl6-errata-14-0129-15 + * @param optionOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfLevelControlClusterMoveToLevelCallback(uint8_t level, uint16_t transitionTime, uint8_t optionMask, + uint8_t optionOverride); +/** @brief Level Control Cluster Move To Level With On Off + * + * + * + * @param level Ver.: always + * @param transitionTime Ver.: always + */ +bool emberAfLevelControlClusterMoveToLevelWithOnOffCallback(uint8_t level, uint16_t transitionTime); +/** @brief Level Control Cluster Move With On Off + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + */ +bool emberAfLevelControlClusterMoveWithOnOffCallback(uint8_t moveMode, uint8_t rate); +/** @brief Level Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfLevelControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Level Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfLevelControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Level Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfLevelControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Level Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfLevelControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Level Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfLevelControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Level Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfLevelControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Level Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfLevelControlClusterServerTickCallback(uint8_t endpoint); +/** @brief Level Control Cluster Step + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + * @param optionMask Ver.: since zcl6-errata-14-0129-15 + * @param optionOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfLevelControlClusterStepCallback(uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime, uint8_t optionMask, + uint8_t optionOverride); +/** @brief Level Control Cluster Step With On Off + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + */ +bool emberAfLevelControlClusterStepWithOnOffCallback(uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime); +/** @brief Level Control Cluster Stop + * + * + * + * @param optionMask Ver.: since zcl6-errata-14-0129-15 + * @param optionOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfLevelControlClusterStopCallback(uint8_t optionMask, uint8_t optionOverride); +/** @brief Level Control Cluster Stop With On Off + * + * + * + */ +bool emberAfLevelControlClusterStopWithOnOffCallback(void); + +/** @} END Level Control Cluster Callbacks */ + +/** @name Alarms Cluster Callbacks */ +// @{ + +/** @brief Alarms Cluster Alarm + * + * + * + * @param alarmCode Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfAlarmClusterAlarmCallback(uint8_t alarmCode, uint16_t clusterId); +/** @brief Alarms Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfAlarmClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Alarms Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfAlarmClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Alarms Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfAlarmClusterClientInitCallback(uint8_t endpoint); +/** @brief Alarms Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfAlarmClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Alarms Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfAlarmClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Alarms Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfAlarmClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Alarms Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfAlarmClusterClientTickCallback(uint8_t endpoint); +/** @brief Alarms Cluster Get Alarm + * + * + * + */ +bool emberAfAlarmClusterGetAlarmCallback(void); +/** @brief Alarms Cluster Get Alarm Response + * + * + * + * @param status Ver.: always + * @param alarmCode Ver.: always + * @param clusterId Ver.: always + * @param timeStamp Ver.: always + */ +bool emberAfAlarmClusterGetAlarmResponseCallback(uint8_t status, uint8_t alarmCode, uint16_t clusterId, uint32_t timeStamp); +/** @brief Alarms Cluster Reset Alarm + * + * + * + * @param alarmCode Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfAlarmClusterResetAlarmCallback(uint8_t alarmCode, uint16_t clusterId); +/** @brief Alarms Cluster Reset Alarm Log + * + * + * + */ +bool emberAfAlarmClusterResetAlarmLogCallback(void); +/** @brief Alarms Cluster Reset All Alarms + * + * + * + */ +bool emberAfAlarmClusterResetAllAlarmsCallback(void); +/** @brief Alarms Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfAlarmClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Alarms Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfAlarmClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Alarms Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfAlarmClusterServerInitCallback(uint8_t endpoint); +/** @brief Alarms Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfAlarmClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Alarms Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfAlarmClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Alarms Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfAlarmClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Alarms Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfAlarmClusterServerTickCallback(uint8_t endpoint); + +/** @} END Alarms Cluster Callbacks */ + +/** @name Time Cluster Callbacks */ +// @{ + +/** @brief Time Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTimeClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Time Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTimeClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Time Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTimeClusterClientInitCallback(uint8_t endpoint); +/** @brief Time Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTimeClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Time Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTimeClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Time Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTimeClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Time Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTimeClusterClientTickCallback(uint8_t endpoint); +/** @brief Time Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTimeClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Time Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTimeClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Time Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTimeClusterServerInitCallback(uint8_t endpoint); +/** @brief Time Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTimeClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Time Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTimeClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Time Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTimeClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Time Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTimeClusterServerTickCallback(uint8_t endpoint); + +/** @} END Time Cluster Callbacks */ + +/** @name RSSI Location Cluster Callbacks */ +// @{ + +/** @brief RSSI Location Cluster Anchor Node Announce + * + * + * + * @param anchorNodeIeeeAddress Ver.: always + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + */ +bool emberAfRssiLocationClusterAnchorNodeAnnounceCallback(uint8_t * anchorNodeIeeeAddress, int16_t coordinate1, int16_t coordinate2, + int16_t coordinate3); +/** @brief RSSI Location Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfRssiLocationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief RSSI Location Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfRssiLocationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief RSSI Location Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfRssiLocationClusterClientInitCallback(uint8_t endpoint); +/** @brief RSSI Location Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfRssiLocationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief RSSI Location Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfRssiLocationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief RSSI Location Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfRssiLocationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief RSSI Location Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfRssiLocationClusterClientTickCallback(uint8_t endpoint); +/** @brief RSSI Location Cluster Compact Location Data Notification + * + * + * + * @param locationType Ver.: always + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + * @param qualityMeasure Ver.: always + * @param locationAge Ver.: always + */ +bool emberAfRssiLocationClusterCompactLocationDataNotificationCallback(uint8_t locationType, int16_t coordinate1, + int16_t coordinate2, int16_t coordinate3, + uint8_t qualityMeasure, uint16_t locationAge); +/** @brief RSSI Location Cluster Device Configuration Response + * + * + * + * @param status Ver.: always + * @param power Ver.: always + * @param pathLossExponent Ver.: always + * @param calculationPeriod Ver.: always + * @param numberRssiMeasurements Ver.: always + * @param reportingPeriod Ver.: always + */ +bool emberAfRssiLocationClusterDeviceConfigurationResponseCallback(uint8_t status, int16_t power, uint16_t pathLossExponent, + uint16_t calculationPeriod, uint8_t numberRssiMeasurements, + uint16_t reportingPeriod); +/** @brief RSSI Location Cluster Get Device Configuration + * + * + * + * @param targetAddress Ver.: always + */ +bool emberAfRssiLocationClusterGetDeviceConfigurationCallback(uint8_t * targetAddress); +/** @brief RSSI Location Cluster Get Location Data + * + * + * + * @param flags Ver.: always + * @param numberResponses Ver.: always + * @param targetAddress Ver.: always + */ +bool emberAfRssiLocationClusterGetLocationDataCallback(uint8_t flags, uint8_t numberResponses, uint8_t * targetAddress); +/** @brief RSSI Location Cluster Location Data Notification + * + * + * + * @param locationType Ver.: always + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + * @param power Ver.: always + * @param pathLossExponent Ver.: always + * @param locationMethod Ver.: always + * @param qualityMeasure Ver.: always + * @param locationAge Ver.: always + */ +bool emberAfRssiLocationClusterLocationDataNotificationCallback(uint8_t locationType, int16_t coordinate1, int16_t coordinate2, + int16_t coordinate3, int16_t power, uint16_t pathLossExponent, + uint8_t locationMethod, uint8_t qualityMeasure, + uint16_t locationAge); +/** @brief RSSI Location Cluster Location Data Response + * + * + * + * @param status Ver.: always + * @param locationType Ver.: always + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + * @param power Ver.: always + * @param pathLossExponent Ver.: always + * @param locationMethod Ver.: always + * @param qualityMeasure Ver.: always + * @param locationAge Ver.: always + */ +bool emberAfRssiLocationClusterLocationDataResponseCallback(uint8_t status, uint8_t locationType, int16_t coordinate1, + int16_t coordinate2, int16_t coordinate3, int16_t power, + uint16_t pathLossExponent, uint8_t locationMethod, + uint8_t qualityMeasure, uint16_t locationAge); +/** @brief RSSI Location Cluster Report Rssi Measurements + * + * + * + * @param measuringDevice Ver.: always + * @param neighbors Ver.: always + * @param neighborsInfo Ver.: always + */ +bool emberAfRssiLocationClusterReportRssiMeasurementsCallback(uint8_t * measuringDevice, uint8_t neighbors, + uint8_t * neighborsInfo); +/** @brief RSSI Location Cluster Request Own Location + * + * + * + * @param blindNode Ver.: always + */ +bool emberAfRssiLocationClusterRequestOwnLocationCallback(uint8_t * blindNode); +/** @brief RSSI Location Cluster Rssi Ping + * + * + * + * @param locationType Ver.: always + */ +bool emberAfRssiLocationClusterRssiPingCallback(uint8_t locationType); +/** @brief RSSI Location Cluster Rssi Request + * + * + * + */ +bool emberAfRssiLocationClusterRssiRequestCallback(void); +/** @brief RSSI Location Cluster Rssi Response + * + * + * + * @param replyingDevice Ver.: always + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + * @param rssi Ver.: always + * @param numberRssiMeasurements Ver.: always + */ +bool emberAfRssiLocationClusterRssiResponseCallback(uint8_t * replyingDevice, int16_t coordinate1, int16_t coordinate2, + int16_t coordinate3, int8_t rssi, uint8_t numberRssiMeasurements); +/** @brief RSSI Location Cluster Send Pings + * + * + * + * @param targetAddress Ver.: always + * @param numberRssiMeasurements Ver.: always + * @param calculationPeriod Ver.: always + */ +bool emberAfRssiLocationClusterSendPingsCallback(uint8_t * targetAddress, uint8_t numberRssiMeasurements, + uint16_t calculationPeriod); +/** @brief RSSI Location Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfRssiLocationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief RSSI Location Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfRssiLocationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief RSSI Location Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfRssiLocationClusterServerInitCallback(uint8_t endpoint); +/** @brief RSSI Location Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfRssiLocationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief RSSI Location Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfRssiLocationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief RSSI Location Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfRssiLocationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief RSSI Location Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfRssiLocationClusterServerTickCallback(uint8_t endpoint); +/** @brief RSSI Location Cluster Set Absolute Location + * + * + * + * @param coordinate1 Ver.: always + * @param coordinate2 Ver.: always + * @param coordinate3 Ver.: always + * @param power Ver.: always + * @param pathLossExponent Ver.: always + */ +bool emberAfRssiLocationClusterSetAbsoluteLocationCallback(int16_t coordinate1, int16_t coordinate2, int16_t coordinate3, + int16_t power, uint16_t pathLossExponent); +/** @brief RSSI Location Cluster Set Device Configuration + * + * + * + * @param power Ver.: always + * @param pathLossExponent Ver.: always + * @param calculationPeriod Ver.: always + * @param numberRssiMeasurements Ver.: always + * @param reportingPeriod Ver.: always + */ +bool emberAfRssiLocationClusterSetDeviceConfigurationCallback(int16_t power, uint16_t pathLossExponent, uint16_t calculationPeriod, + uint8_t numberRssiMeasurements, uint16_t reportingPeriod); + +/** @} END RSSI Location Cluster Callbacks */ + +/** @name Binary Input (Basic) Cluster Callbacks */ +// @{ + +/** @brief Binary Input (Basic) Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBinaryInputBasicClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Binary Input (Basic) Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBinaryInputBasicClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Binary Input (Basic) Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBinaryInputBasicClusterClientInitCallback(uint8_t endpoint); +/** @brief Binary Input (Basic) Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBinaryInputBasicClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Binary Input (Basic) Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBinaryInputBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Binary Input (Basic) Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBinaryInputBasicClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Binary Input (Basic) Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBinaryInputBasicClusterClientTickCallback(uint8_t endpoint); +/** @brief Binary Input (Basic) Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBinaryInputBasicClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Binary Input (Basic) Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBinaryInputBasicClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Binary Input (Basic) Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBinaryInputBasicClusterServerInitCallback(uint8_t endpoint); +/** @brief Binary Input (Basic) Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBinaryInputBasicClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Binary Input (Basic) Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBinaryInputBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Binary Input (Basic) Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBinaryInputBasicClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Binary Input (Basic) Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBinaryInputBasicClusterServerTickCallback(uint8_t endpoint); + +/** @} END Binary Input (Basic) Cluster Callbacks */ + +/** @name Commissioning Cluster Callbacks */ +// @{ + +/** @brief Commissioning Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCommissioningClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Commissioning Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCommissioningClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Commissioning Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCommissioningClusterClientInitCallback(uint8_t endpoint); +/** @brief Commissioning Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCommissioningClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Commissioning Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCommissioningClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Commissioning Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCommissioningClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Commissioning Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCommissioningClusterClientTickCallback(uint8_t endpoint); +/** @brief Commissioning Cluster Reset Startup Parameters + * + * + * + * @param options Ver.: always + * @param index Ver.: always + */ +bool emberAfCommissioningClusterResetStartupParametersCallback(uint8_t options, uint8_t index); +/** @brief Commissioning Cluster Reset Startup Parameters Response + * + * + * + * @param status Ver.: always + */ +bool emberAfCommissioningClusterResetStartupParametersResponseCallback(uint8_t status); +/** @brief Commissioning Cluster Restart Device + * + * + * + * @param options Ver.: always + * @param delay Ver.: always + * @param jitter Ver.: always + */ +bool emberAfCommissioningClusterRestartDeviceCallback(uint8_t options, uint8_t delay, uint8_t jitter); +/** @brief Commissioning Cluster Restart Device Response + * + * + * + * @param status Ver.: always + */ +bool emberAfCommissioningClusterRestartDeviceResponseCallback(uint8_t status); +/** @brief Commissioning Cluster Restore Startup Parameters + * + * + * + * @param options Ver.: always + * @param index Ver.: always + */ +bool emberAfCommissioningClusterRestoreStartupParametersCallback(uint8_t options, uint8_t index); +/** @brief Commissioning Cluster Restore Startup Parameters Response + * + * + * + * @param status Ver.: always + */ +bool emberAfCommissioningClusterRestoreStartupParametersResponseCallback(uint8_t status); +/** @brief Commissioning Cluster Save Startup Parameters + * + * + * + * @param options Ver.: always + * @param index Ver.: always + */ +bool emberAfCommissioningClusterSaveStartupParametersCallback(uint8_t options, uint8_t index); +/** @brief Commissioning Cluster Save Startup Parameters Response + * + * + * + * @param status Ver.: always + */ +bool emberAfCommissioningClusterSaveStartupParametersResponseCallback(uint8_t status); +/** @brief Commissioning Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCommissioningClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Commissioning Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCommissioningClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Commissioning Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCommissioningClusterServerInitCallback(uint8_t endpoint); +/** @brief Commissioning Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Commissioning Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Commissioning Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCommissioningClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Commissioning Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCommissioningClusterServerTickCallback(uint8_t endpoint); + +/** @} END Commissioning Cluster Callbacks */ + +/** @name Partition Cluster Callbacks */ +// @{ + +/** @brief Partition Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPartitionClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Partition Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPartitionClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Partition Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPartitionClusterClientInitCallback(uint8_t endpoint); +/** @brief Partition Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPartitionClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Partition Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPartitionClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Partition Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPartitionClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Partition Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPartitionClusterClientTickCallback(uint8_t endpoint); +/** @brief Partition Cluster Multiple Ack + * + * + * + * @param ackOptions Ver.: always + * @param firstFrameIdAndNackList Ver.: always + */ +bool emberAfPartitionClusterMultipleAckCallback(uint8_t ackOptions, uint8_t * firstFrameIdAndNackList); +/** @brief Partition Cluster Read Handshake Param + * + * + * + * @param partitionedClusterId Ver.: always + * @param attributeList Ver.: always + */ +bool emberAfPartitionClusterReadHandshakeParamCallback(uint16_t partitionedClusterId, uint8_t * attributeList); +/** @brief Partition Cluster Read Handshake Param Response + * + * + * + * @param partitionedClusterId Ver.: always + * @param readAttributeStatusRecords Ver.: always + */ +bool emberAfPartitionClusterReadHandshakeParamResponseCallback(uint16_t partitionedClusterId, uint8_t * readAttributeStatusRecords); +/** @brief Partition Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPartitionClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Partition Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPartitionClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Partition Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPartitionClusterServerInitCallback(uint8_t endpoint); +/** @brief Partition Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPartitionClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Partition Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPartitionClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Partition Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPartitionClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Partition Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPartitionClusterServerTickCallback(uint8_t endpoint); +/** @brief Partition Cluster Transfer Partitioned Frame + * + * + * + * @param fragmentationOptions Ver.: always + * @param partitionedIndicatorAndFrame Ver.: always + */ +bool emberAfPartitionClusterTransferPartitionedFrameCallback(uint8_t fragmentationOptions, uint8_t * partitionedIndicatorAndFrame); +/** @brief Partition Cluster Write Handshake Param + * + * + * + * @param partitionedClusterId Ver.: always + * @param writeAttributeRecords Ver.: always + */ +bool emberAfPartitionClusterWriteHandshakeParamCallback(uint16_t partitionedClusterId, uint8_t * writeAttributeRecords); + +/** @} END Partition Cluster Callbacks */ + +/** @name Over the Air Bootloading Cluster Callbacks */ +// @{ + +/** @brief Over the Air Bootloading Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOtaBootloadClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Over the Air Bootloading Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOtaBootloadClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Over the Air Bootloading Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOtaBootloadClusterClientInitCallback(uint8_t endpoint); +/** @brief Over the Air Bootloading Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOtaBootloadClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Over the Air Bootloading Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOtaBootloadClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Over the Air Bootloading Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOtaBootloadClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Over the Air Bootloading Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOtaBootloadClusterClientTickCallback(uint8_t endpoint); +/** @brief Over the Air Bootloading Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOtaBootloadClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Over the Air Bootloading Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOtaBootloadClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Over the Air Bootloading Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOtaBootloadClusterServerInitCallback(uint8_t endpoint); +/** @brief Over the Air Bootloading Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOtaBootloadClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Over the Air Bootloading Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOtaBootloadClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Over the Air Bootloading Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOtaBootloadClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Over the Air Bootloading Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOtaBootloadClusterServerTickCallback(uint8_t endpoint); + +/** @} END Over the Air Bootloading Cluster Callbacks */ + +/** @name Power Profile Cluster Callbacks */ +// @{ + +/** @brief Power Profile Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPowerProfileClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Power Profile Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPowerProfileClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Power Profile Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPowerProfileClusterClientInitCallback(uint8_t endpoint); +/** @brief Power Profile Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPowerProfileClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Power Profile Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPowerProfileClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Power Profile Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPowerProfileClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Power Profile Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPowerProfileClusterClientTickCallback(uint8_t endpoint); +/** @brief Power Profile Cluster Energy Phases Schedule Notification + * + * + * + * @param powerProfileId Ver.: always + * @param numOfScheduledPhases Ver.: always + * @param scheduledPhases Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleNotificationCallback(uint8_t powerProfileId, uint8_t numOfScheduledPhases, + uint8_t * scheduledPhases); +/** @brief Power Profile Cluster Energy Phases Schedule Request + * + * + * + * @param powerProfileId Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleRequestCallback(uint8_t powerProfileId); +/** @brief Power Profile Cluster Energy Phases Schedule Response + * + * + * + * @param powerProfileId Ver.: always + * @param numOfScheduledPhases Ver.: always + * @param scheduledPhases Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleResponseCallback(uint8_t powerProfileId, uint8_t numOfScheduledPhases, + uint8_t * scheduledPhases); +/** @brief Power Profile Cluster Energy Phases Schedule State Notification + * + * + * + * @param powerProfileId Ver.: always + * @param numOfScheduledPhases Ver.: always + * @param scheduledPhases Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleStateNotificationCallback(uint8_t powerProfileId, uint8_t numOfScheduledPhases, + uint8_t * scheduledPhases); +/** @brief Power Profile Cluster Energy Phases Schedule State Request + * + * + * + * @param powerProfileId Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleStateRequestCallback(uint8_t powerProfileId); +/** @brief Power Profile Cluster Energy Phases Schedule State Response + * + * + * + * @param powerProfileId Ver.: always + * @param numOfScheduledPhases Ver.: always + * @param scheduledPhases Ver.: always + */ +bool emberAfPowerProfileClusterEnergyPhasesScheduleStateResponseCallback(uint8_t powerProfileId, uint8_t numOfScheduledPhases, + uint8_t * scheduledPhases); +/** @brief Power Profile Cluster Get Overall Schedule Price + * + * + * + */ +bool emberAfPowerProfileClusterGetOverallSchedulePriceCallback(void); +/** @brief Power Profile Cluster Get Overall Schedule Price Response + * + * + * + * @param currency Ver.: always + * @param price Ver.: always + * @param priceTrailingDigit Ver.: always + */ +bool emberAfPowerProfileClusterGetOverallSchedulePriceResponseCallback(uint16_t currency, uint32_t price, + uint8_t priceTrailingDigit); +/** @brief Power Profile Cluster Get Power Profile Price + * + * + * + * @param powerProfileId Ver.: always + */ +bool emberAfPowerProfileClusterGetPowerProfilePriceCallback(uint8_t powerProfileId); +/** @brief Power Profile Cluster Get Power Profile Price Extended + * + * + * + * @param options Ver.: always + * @param powerProfileId Ver.: always + * @param powerProfileStartTime Ver.: always + */ +bool emberAfPowerProfileClusterGetPowerProfilePriceExtendedCallback(uint8_t options, uint8_t powerProfileId, + uint16_t powerProfileStartTime); +/** @brief Power Profile Cluster Get Power Profile Price Extended Response + * + * + * + * @param powerProfileId Ver.: always + * @param currency Ver.: always + * @param price Ver.: always + * @param priceTrailingDigit Ver.: always + */ +bool emberAfPowerProfileClusterGetPowerProfilePriceExtendedResponseCallback(uint8_t powerProfileId, uint16_t currency, + uint32_t price, uint8_t priceTrailingDigit); +/** @brief Power Profile Cluster Get Power Profile Price Response + * + * + * + * @param powerProfileId Ver.: always + * @param currency Ver.: always + * @param price Ver.: always + * @param priceTrailingDigit Ver.: always + */ +bool emberAfPowerProfileClusterGetPowerProfilePriceResponseCallback(uint8_t powerProfileId, uint16_t currency, uint32_t price, + uint8_t priceTrailingDigit); +/** @brief Power Profile Cluster Power Profile Notification + * + * + * + * @param totalProfileNum Ver.: always + * @param powerProfileId Ver.: always + * @param numOfTransferredPhases Ver.: always + * @param transferredPhases Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileNotificationCallback(uint8_t totalProfileNum, uint8_t powerProfileId, + uint8_t numOfTransferredPhases, uint8_t * transferredPhases); +/** @brief Power Profile Cluster Power Profile Request + * + * + * + * @param powerProfileId Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileRequestCallback(uint8_t powerProfileId); +/** @brief Power Profile Cluster Power Profile Response + * + * + * + * @param totalProfileNum Ver.: always + * @param powerProfileId Ver.: always + * @param numOfTransferredPhases Ver.: always + * @param transferredPhases Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileResponseCallback(uint8_t totalProfileNum, uint8_t powerProfileId, + uint8_t numOfTransferredPhases, uint8_t * transferredPhases); +/** @brief Power Profile Cluster Power Profile Schedule Constraints Notification + * + * + * + * @param powerProfileId Ver.: always + * @param startAfter Ver.: always + * @param stopBefore Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsNotificationCallback(uint8_t powerProfileId, uint16_t startAfter, + uint16_t stopBefore); +/** @brief Power Profile Cluster Power Profile Schedule Constraints Request + * + * + * + * @param powerProfileId Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsRequestCallback(uint8_t powerProfileId); +/** @brief Power Profile Cluster Power Profile Schedule Constraints Response + * + * + * + * @param powerProfileId Ver.: always + * @param startAfter Ver.: always + * @param stopBefore Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileScheduleConstraintsResponseCallback(uint8_t powerProfileId, uint16_t startAfter, + uint16_t stopBefore); +/** @brief Power Profile Cluster Power Profile State Request + * + * + * + */ +bool emberAfPowerProfileClusterPowerProfileStateRequestCallback(void); +/** @brief Power Profile Cluster Power Profile State Response + * + * + * + * @param powerProfileCount Ver.: always + * @param powerProfileRecords Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfileStateResponseCallback(uint8_t powerProfileCount, uint8_t * powerProfileRecords); +/** @brief Power Profile Cluster Power Profiles State Notification + * + * + * + * @param powerProfileCount Ver.: always + * @param powerProfileRecords Ver.: always + */ +bool emberAfPowerProfileClusterPowerProfilesStateNotificationCallback(uint8_t powerProfileCount, uint8_t * powerProfileRecords); +/** @brief Power Profile Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPowerProfileClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Power Profile Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPowerProfileClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Power Profile Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPowerProfileClusterServerInitCallback(uint8_t endpoint); +/** @brief Power Profile Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPowerProfileClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Power Profile Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPowerProfileClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Power Profile Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPowerProfileClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Power Profile Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPowerProfileClusterServerTickCallback(uint8_t endpoint); + +/** @} END Power Profile Cluster Callbacks */ + +/** @name Appliance Control Cluster Callbacks */ +// @{ + +/** @brief Appliance Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Appliance Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Appliance Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Appliance Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Appliance Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Appliance Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Appliance Control Cluster Execution Of A Command + * + * + * + * @param commandId Ver.: always + */ +bool emberAfApplianceControlClusterExecutionOfACommandCallback(uint8_t commandId); +/** @brief Appliance Control Cluster Overload Pause + * + * + * + */ +bool emberAfApplianceControlClusterOverloadPauseCallback(void); +/** @brief Appliance Control Cluster Overload Pause Resume + * + * + * + */ +bool emberAfApplianceControlClusterOverloadPauseResumeCallback(void); +/** @brief Appliance Control Cluster Overload Warning + * + * + * + * @param warningEvent Ver.: always + */ +bool emberAfApplianceControlClusterOverloadWarningCallback(uint8_t warningEvent); +/** @brief Appliance Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Appliance Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Appliance Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Appliance Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Appliance Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Appliance Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceControlClusterServerTickCallback(uint8_t endpoint); +/** @brief Appliance Control Cluster Signal State + * + * + * + */ +bool emberAfApplianceControlClusterSignalStateCallback(void); +/** @brief Appliance Control Cluster Signal State Notification + * + * + * + * @param applianceStatus Ver.: always + * @param remoteEnableFlagsAndDeviceStatus2 Ver.: always + * @param applianceStatus2 Ver.: always + */ +bool emberAfApplianceControlClusterSignalStateNotificationCallback(uint8_t applianceStatus, + uint8_t remoteEnableFlagsAndDeviceStatus2, + uint32_t applianceStatus2); +/** @brief Appliance Control Cluster Signal State Response + * + * + * + * @param applianceStatus Ver.: always + * @param remoteEnableFlagsAndDeviceStatus2 Ver.: always + * @param applianceStatus2 Ver.: always + */ +bool emberAfApplianceControlClusterSignalStateResponseCallback(uint8_t applianceStatus, uint8_t remoteEnableFlagsAndDeviceStatus2, + uint32_t applianceStatus2); +/** @brief Appliance Control Cluster Write Functions + * + * + * + * @param functionId Ver.: always + * @param functionDataType Ver.: always + * @param functionData Ver.: always + */ +bool emberAfApplianceControlClusterWriteFunctionsCallback(uint16_t functionId, uint8_t functionDataType, uint8_t * functionData); + +/** @} END Appliance Control Cluster Callbacks */ + +/** @name Poll Control Cluster Callbacks */ +// @{ + +/** @brief Poll Control Cluster Check In + * + * + * + */ +bool emberAfPollControlClusterCheckInCallback(void); +/** @brief Poll Control Cluster Check In Response + * + * + * + * @param startFastPolling Ver.: always + * @param fastPollTimeout Ver.: always + */ +bool emberAfPollControlClusterCheckInResponseCallback(uint8_t startFastPolling, uint16_t fastPollTimeout); +/** @brief Poll Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPollControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Poll Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPollControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Poll Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPollControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Poll Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPollControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Poll Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPollControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Poll Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPollControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Poll Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPollControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Poll Control Cluster Fast Poll Stop + * + * + * + */ +bool emberAfPollControlClusterFastPollStopCallback(void); +/** @brief Poll Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPollControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Poll Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPollControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Poll Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPollControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Poll Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPollControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Poll Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPollControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Poll Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPollControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Poll Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPollControlClusterServerTickCallback(uint8_t endpoint); +/** @brief Poll Control Cluster Set Long Poll Interval + * + * + * + * @param newLongPollInterval Ver.: always + */ +bool emberAfPollControlClusterSetLongPollIntervalCallback(uint32_t newLongPollInterval); +/** @brief Poll Control Cluster Set Short Poll Interval + * + * + * + * @param newShortPollInterval Ver.: always + */ +bool emberAfPollControlClusterSetShortPollIntervalCallback(uint16_t newShortPollInterval); + +/** @} END Poll Control Cluster Callbacks */ + +/** @name Green Power Cluster Callbacks */ +// @{ + +/** @brief Green Power Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGreenPowerClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Green Power Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGreenPowerClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Green Power Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGreenPowerClusterClientInitCallback(uint8_t endpoint); +/** @brief Green Power Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGreenPowerClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Green Power Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGreenPowerClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Green Power Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGreenPowerClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Green Power Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGreenPowerClusterClientTickCallback(uint8_t endpoint); +/** @brief Green Power Cluster Gp Commissioning Notification + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + * @param gpdCommandId Ver.: since gp-1.0-09-5499-24 + * @param gpdCommandPayload Ver.: since gp-1.0-09-5499-24 + * @param gppShortAddress Ver.: since gp-1.0-09-5499-24 + * @param gppLink Ver.: since gp-1.0-09-5499-24 + * @param mic Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpCommissioningNotificationCallback(uint16_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, + uint8_t endpoint, uint32_t gpdSecurityFrameCounter, + uint8_t gpdCommandId, uint8_t * gpdCommandPayload, + uint16_t gppShortAddress, uint8_t gppLink, uint32_t mic); +/** @brief Green Power Cluster Gp Notification + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param gpdEndpoint Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + * @param gpdCommandId Ver.: since gp-1.0-09-5499-24 + * @param gpdCommandPayload Ver.: since gp-1.0-09-5499-24 + * @param gppShortAddress Ver.: since gp-1.0-09-5499-24 + * @param gppDistance Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpNotificationCallback(uint16_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t gpdEndpoint, + uint32_t gpdSecurityFrameCounter, uint8_t gpdCommandId, + uint8_t * gpdCommandPayload, uint16_t gppShortAddress, uint8_t gppDistance); +/** @brief Green Power Cluster Gp Notification Response + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpNotificationResponseCallback(uint8_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, + uint32_t gpdSecurityFrameCounter); +/** @brief Green Power Cluster Gp Pairing + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param sinkIeeeAddress Ver.: since gp-1.0-09-5499-24 + * @param sinkNwkAddress Ver.: since gp-1.0-09-5499-24 + * @param sinkGroupId Ver.: since gp-1.0-09-5499-24 + * @param deviceId Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + * @param gpdKey Ver.: since gp-1.0-09-5499-24 + * @param assignedAlias Ver.: since gp-1.0-09-5499-24 + * @param groupcastRadius Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpPairingCallback(uint32_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, + uint8_t * sinkIeeeAddress, uint16_t sinkNwkAddress, uint16_t sinkGroupId, + uint8_t deviceId, uint32_t gpdSecurityFrameCounter, uint8_t * gpdKey, + uint16_t assignedAlias, uint8_t groupcastRadius); +/** @brief Green Power Cluster Gp Pairing Configuration + * + * + * + * @param actions Ver.: since gp-1.0-09-5499-24 + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param deviceId Ver.: since gp-1.0-09-5499-24 + * @param groupListCount Ver.: since gp-1.0-09-5499-24 + * @param groupList Ver.: since gp-1.0-09-5499-24 + * @param gpdAssignedAlias Ver.: since gp-1.0-09-5499-24 + * @param groupcastRadius Ver.: since gp-1.0-15-2014-05-CCB2180 + * @param securityOptions Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityKey Ver.: since gp-1.0-09-5499-24 + * @param numberOfPairedEndpoints Ver.: since gp-1.0-09-5499-24 + * @param pairedEndpoints Ver.: since gp-1.0-09-5499-24 + * @param applicationInformation Ver.: always + * @param manufacturerId Ver.: always + * @param modeId Ver.: always + * @param numberOfGpdCommands Ver.: always + * @param gpdCommandIdList Ver.: always + * @param clusterIdListCount Ver.: always + * @param clusterListServer Ver.: always + * @param clusterListClient Ver.: always + * @param switchInformationLength Ver.: always + * @param switchConfiguration Ver.: always + * @param currentContactStatus Ver.: always + * @param totalNumberOfReports Ver.: always + * @param numberOfReports Ver.: always + * @param reportDescriptor Ver.: always + */ +bool emberAfGreenPowerClusterGpPairingConfigurationCallback( + uint8_t actions, uint16_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, uint8_t deviceId, + uint8_t groupListCount, uint8_t * groupList, uint16_t gpdAssignedAlias, uint8_t groupcastRadius, uint8_t securityOptions, + uint32_t gpdSecurityFrameCounter, uint8_t * gpdSecurityKey, uint8_t numberOfPairedEndpoints, uint8_t * pairedEndpoints, + uint8_t applicationInformation, uint16_t manufacturerId, uint16_t modeId, uint8_t numberOfGpdCommands, + uint8_t * gpdCommandIdList, uint8_t clusterIdListCount, uint8_t * clusterListServer, uint8_t * clusterListClient, + uint8_t switchInformationLength, uint8_t switchConfiguration, uint8_t currentContactStatus, uint8_t totalNumberOfReports, + uint8_t numberOfReports, uint8_t * reportDescriptor); +/** @brief Green Power Cluster Gp Pairing Search + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: always + */ +bool emberAfGreenPowerClusterGpPairingSearchCallback(uint16_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint); +/** @brief Green Power Cluster Gp Proxy Commissioning Mode + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param commissioningWindow Ver.: since gp-1.0-15-02014-011 + * @param channel Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpProxyCommissioningModeCallback(uint8_t options, uint16_t commissioningWindow, uint8_t channel); +/** @brief Green Power Cluster Gp Proxy Table Request + * + * + * + * @param options Ver.: always + * @param gpdSrcId Ver.: always + * @param gpdIeee Ver.: always + * @param endpoint Ver.: always + * @param index Ver.: always + */ +bool emberAfGreenPowerClusterGpProxyTableRequestCallback(uint8_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, + uint8_t index); +/** @brief Green Power Cluster Gp Proxy Table Response + * + * + * + * @param status Ver.: always + * @param totalNumberOfNonEmptyProxyTableEntries Ver.: always + * @param startIndex Ver.: always + * @param entriesCount Ver.: always + * @param proxyTableEntries Ver.: always + */ +bool emberAfGreenPowerClusterGpProxyTableResponseCallback(uint8_t status, uint8_t totalNumberOfNonEmptyProxyTableEntries, + uint8_t startIndex, uint8_t entriesCount, uint8_t * proxyTableEntries); +/** @brief Green Power Cluster Gp Response + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param tempMasterShortAddress Ver.: since gp-1.0-09-5499-24 + * @param tempMasterTxChannel Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: always + * @param gpdCommandId Ver.: since gp-1.0-09-5499-24 + * @param gpdCommandPayload Ver.: always + */ +bool emberAfGreenPowerClusterGpResponseCallback(uint8_t options, uint16_t tempMasterShortAddress, uint8_t tempMasterTxChannel, + uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, uint8_t gpdCommandId, + uint8_t * gpdCommandPayload); +/** @brief Green Power Cluster Gp Sink Commissioning Mode + * + * + * + * @param options Ver.: always + * @param gpmAddrForSecurity Ver.: always + * @param gpmAddrForPairing Ver.: always + * @param sinkEndpoint Ver.: always + */ +bool emberAfGreenPowerClusterGpSinkCommissioningModeCallback(uint8_t options, uint16_t gpmAddrForSecurity, + uint16_t gpmAddrForPairing, uint8_t sinkEndpoint); +/** @brief Green Power Cluster Gp Sink Table Request + * + * + * + * @param options Ver.: always + * @param gpdSrcId Ver.: always + * @param gpdIeee Ver.: always + * @param endpoint Ver.: always + * @param index Ver.: always + */ +bool emberAfGreenPowerClusterGpSinkTableRequestCallback(uint8_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, + uint8_t index); +/** @brief Green Power Cluster Gp Sink Table Response + * + * + * + * @param status Ver.: always + * @param totalNumberofNonEmptySinkTableEntries Ver.: always + * @param startIndex Ver.: always + * @param sinkTableEntriesCount Ver.: always + * @param sinkTableEntries Ver.: always + */ +bool emberAfGreenPowerClusterGpSinkTableResponseCallback(uint8_t status, uint8_t totalNumberofNonEmptySinkTableEntries, + uint8_t startIndex, uint8_t sinkTableEntriesCount, + uint8_t * sinkTableEntries); +/** @brief Green Power Cluster Gp Translation Table Request + * + * + * + * @param startIndex Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpTranslationTableRequestCallback(uint8_t startIndex); +/** @brief Green Power Cluster Gp Translation Table Response + * + * + * + * @param status Ver.: since gp-1.0-09-5499-24 + * @param options Ver.: since gp-1.0-09-5499-24 + * @param totalNumberOfEntries Ver.: since gp-1.0-09-5499-24 + * @param startIndex Ver.: since gp-1.0-09-5499-24 + * @param entriesCount Ver.: since gp-1.0-09-5499-24 + * @param translationTableList Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpTranslationTableResponseCallback(uint8_t status, uint8_t options, uint8_t totalNumberOfEntries, + uint8_t startIndex, uint8_t entriesCount, + uint8_t * translationTableList); +/** @brief Green Power Cluster Gp Translation Table Update + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param translations Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpTranslationTableUpdateCallback(uint16_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, + uint8_t endpoint, uint8_t * translations); +/** @brief Green Power Cluster Gp Tunneling Stop + * + * + * + * @param options Ver.: since gp-1.0-09-5499-24 + * @param gpdSrcId Ver.: since gp-1.0-09-5499-24 + * @param gpdIeee Ver.: since gp-1.0-09-5499-24 + * @param endpoint Ver.: since gp-1.0-09-5499-24 + * @param gpdSecurityFrameCounter Ver.: since gp-1.0-09-5499-24 + * @param gppShortAddress Ver.: since gp-1.0-09-5499-24 + * @param gppDistance Ver.: since gp-1.0-09-5499-24 + */ +bool emberAfGreenPowerClusterGpTunnelingStopCallback(uint8_t options, uint32_t gpdSrcId, uint8_t * gpdIeee, uint8_t endpoint, + uint32_t gpdSecurityFrameCounter, uint16_t gppShortAddress, + int8_t gppDistance); +/** @brief Green Power Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGreenPowerClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Green Power Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGreenPowerClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Green Power Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGreenPowerClusterServerInitCallback(uint8_t endpoint); +/** @brief Green Power Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGreenPowerClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Green Power Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGreenPowerClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Green Power Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGreenPowerClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Green Power Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGreenPowerClusterServerTickCallback(uint8_t endpoint); + +/** @} END Green Power Cluster Callbacks */ + +/** @name Keep-Alive Cluster Callbacks */ +// @{ + +/** @brief Keep-Alive Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfKeepaliveClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Keep-Alive Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfKeepaliveClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Keep-Alive Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfKeepaliveClusterClientInitCallback(uint8_t endpoint); +/** @brief Keep-Alive Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfKeepaliveClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Keep-Alive Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfKeepaliveClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Keep-Alive Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfKeepaliveClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Keep-Alive Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfKeepaliveClusterClientTickCallback(uint8_t endpoint); +/** @brief Keep-Alive Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfKeepaliveClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Keep-Alive Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfKeepaliveClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Keep-Alive Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfKeepaliveClusterServerInitCallback(uint8_t endpoint); +/** @brief Keep-Alive Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfKeepaliveClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Keep-Alive Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfKeepaliveClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Keep-Alive Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfKeepaliveClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Keep-Alive Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfKeepaliveClusterServerTickCallback(uint8_t endpoint); + +/** @} END Keep-Alive Cluster Callbacks */ + +/** @name Shade Configuration Cluster Callbacks */ +// @{ + +/** @brief Shade Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfShadeConfigClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Shade Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfShadeConfigClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Shade Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfShadeConfigClusterClientInitCallback(uint8_t endpoint); +/** @brief Shade Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfShadeConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Shade Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfShadeConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Shade Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfShadeConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Shade Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfShadeConfigClusterClientTickCallback(uint8_t endpoint); +/** @brief Shade Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfShadeConfigClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Shade Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfShadeConfigClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Shade Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfShadeConfigClusterServerInitCallback(uint8_t endpoint); +/** @brief Shade Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfShadeConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Shade Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfShadeConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Shade Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfShadeConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Shade Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfShadeConfigClusterServerTickCallback(uint8_t endpoint); + +/** @} END Shade Configuration Cluster Callbacks */ + +/** @name Door Lock Cluster Callbacks */ +// @{ + +/** @brief Door Lock Cluster Clear All Pins + * + * + * + */ +bool emberAfDoorLockClusterClearAllPinsCallback(void); +/** @brief Door Lock Cluster Clear All Pins Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearAllPinsResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear All Rfids + * + * + * + */ +bool emberAfDoorLockClusterClearAllRfidsCallback(void); +/** @brief Door Lock Cluster Clear All Rfids Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearAllRfidsResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear Holiday Schedule + * + * + * + * @param scheduleId Ver.: always + */ +bool emberAfDoorLockClusterClearHolidayScheduleCallback(uint8_t scheduleId); +/** @brief Door Lock Cluster Clear Holiday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearHolidayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear Pin + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearPinCallback(uint16_t userId); +/** @brief Door Lock Cluster Clear Pin Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearPinResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear Rfid + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearRfidCallback(uint16_t userId); +/** @brief Door Lock Cluster Clear Rfid Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearRfidResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear Weekday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId); +/** @brief Door Lock Cluster Clear Weekday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearWeekdayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Clear Yearday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId); +/** @brief Door Lock Cluster Clear Yearday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterClearYeardayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDoorLockClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Door Lock Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDoorLockClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Door Lock Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDoorLockClusterClientInitCallback(uint8_t endpoint); +/** @brief Door Lock Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDoorLockClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Door Lock Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDoorLockClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Door Lock Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDoorLockClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Door Lock Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDoorLockClusterClientTickCallback(uint8_t endpoint); +/** @brief Door Lock Cluster Get Holiday Schedule + * + * + * + * @param scheduleId Ver.: always + */ +bool emberAfDoorLockClusterGetHolidayScheduleCallback(uint8_t scheduleId); +/** @brief Door Lock Cluster Get Holiday Schedule Response + * + * + * + * @param scheduleId Ver.: always + * @param status Ver.: always + * @param localStartTime Ver.: since ha-1.2-05-3520-29 + * @param localEndTime Ver.: since ha-1.2-05-3520-29 + * @param operatingModeDuringHoliday Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterGetHolidayScheduleResponseCallback(uint8_t scheduleId, uint8_t status, uint32_t localStartTime, + uint32_t localEndTime, uint8_t operatingModeDuringHoliday); +/** @brief Door Lock Cluster Get Log Record + * + * + * + * @param logIndex Ver.: always + */ +bool emberAfDoorLockClusterGetLogRecordCallback(uint16_t logIndex); +/** @brief Door Lock Cluster Get Log Record Response + * + * + * + * @param logEntryId Ver.: always + * @param timestamp Ver.: always + * @param eventType Ver.: always + * @param source Ver.: always + * @param eventIdOrAlarmCode Ver.: always + * @param userId Ver.: always + * @param pin Ver.: always + */ +bool emberAfDoorLockClusterGetLogRecordResponseCallback(uint16_t logEntryId, uint32_t timestamp, uint8_t eventType, uint8_t source, + uint8_t eventIdOrAlarmCode, uint16_t userId, uint8_t * pin); +/** @brief Door Lock Cluster Get Pin + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetPinCallback(uint16_t userId); +/** @brief Door Lock Cluster Get Pin Response + * + * + * + * @param userId Ver.: always + * @param userStatus Ver.: always + * @param userType Ver.: always + * @param pin Ver.: always + */ +bool emberAfDoorLockClusterGetPinResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin); +/** @brief Door Lock Cluster Get Rfid + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetRfidCallback(uint16_t userId); +/** @brief Door Lock Cluster Get Rfid Response + * + * + * + * @param userId Ver.: always + * @param userStatus Ver.: always + * @param userType Ver.: always + * @param rfid Ver.: always + */ +bool emberAfDoorLockClusterGetRfidResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * rfid); +/** @brief Door Lock Cluster Get User Status + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetUserStatusCallback(uint16_t userId); +/** @brief Door Lock Cluster Get User Status Response + * + * + * + * @param userId Ver.: always + * @param status Ver.: always + */ +bool emberAfDoorLockClusterGetUserStatusResponseCallback(uint16_t userId, uint8_t status); +/** @brief Door Lock Cluster Get User Type + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetUserTypeCallback(uint16_t userId); +/** @brief Door Lock Cluster Get User Type Response + * + * + * + * @param userId Ver.: always + * @param userType Ver.: always + */ +bool emberAfDoorLockClusterGetUserTypeResponseCallback(uint16_t userId, uint8_t userType); +/** @brief Door Lock Cluster Get Weekday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId); +/** @brief Door Lock Cluster Get Weekday Schedule Response + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + * @param status Ver.: always + * @param daysMask Ver.: since ha-1.2-05-3520-29 + * @param startHour Ver.: since ha-1.2-05-3520-29 + * @param startMinute Ver.: since ha-1.2-05-3520-29 + * @param endHour Ver.: since ha-1.2-05-3520-29 + * @param endMinute Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterGetWeekdayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status, uint8_t daysMask, + uint8_t startHour, uint8_t startMinute, uint8_t endHour, + uint8_t endMinute); +/** @brief Door Lock Cluster Get Yearday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId); +/** @brief Door Lock Cluster Get Yearday Schedule Response + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + * @param status Ver.: always + * @param localStartTime Ver.: since ha-1.2-05-3520-29 + * @param localEndTime Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterGetYeardayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status, + uint32_t localStartTime, uint32_t localEndTime); +/** @brief Door Lock Cluster Lock Door + * + * + * + * @param PIN Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterLockDoorCallback(uint8_t * PIN); +/** @brief Door Lock Cluster Lock Door Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterLockDoorResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Operation Event Notification + * + * + * + * @param source Ver.: always + * @param eventCode Ver.: always + * @param userId Ver.: always + * @param pin Ver.: always + * @param timeStamp Ver.: always + * @param data Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterOperationEventNotificationCallback(uint8_t source, uint8_t eventCode, uint16_t userId, uint8_t * pin, + uint32_t timeStamp, uint8_t * data); +/** @brief Door Lock Cluster Programming Event Notification + * + * + * + * @param source Ver.: always + * @param eventCode Ver.: always + * @param userId Ver.: always + * @param pin Ver.: always + * @param userType Ver.: always + * @param userStatus Ver.: always + * @param timeStamp Ver.: always + * @param data Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterProgrammingEventNotificationCallback(uint8_t source, uint8_t eventCode, uint16_t userId, uint8_t * pin, + uint8_t userType, uint8_t userStatus, uint32_t timeStamp, + uint8_t * data); +/** @brief Door Lock Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDoorLockClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Door Lock Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDoorLockClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Door Lock Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDoorLockClusterServerInitCallback(uint8_t endpoint); +/** @brief Door Lock Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDoorLockClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Door Lock Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDoorLockClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Door Lock Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDoorLockClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Door Lock Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDoorLockClusterServerTickCallback(uint8_t endpoint); +/** @brief Door Lock Cluster Set Holiday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param localStartTime Ver.: always + * @param localEndTime Ver.: always + * @param operatingModeDuringHoliday Ver.: always + */ +bool emberAfDoorLockClusterSetHolidayScheduleCallback(uint8_t scheduleId, uint32_t localStartTime, uint32_t localEndTime, + uint8_t operatingModeDuringHoliday); +/** @brief Door Lock Cluster Set Holiday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetHolidayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set Pin + * + * + * + * @param userId Ver.: always + * @param userStatus Ver.: always + * @param userType Ver.: always + * @param pin Ver.: always + */ +bool emberAfDoorLockClusterSetPinCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin); +/** @brief Door Lock Cluster Set Pin Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetPinResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set Rfid + * + * + * + * @param userId Ver.: always + * @param userStatus Ver.: always + * @param userType Ver.: always + * @param id Ver.: always + */ +bool emberAfDoorLockClusterSetRfidCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * id); +/** @brief Door Lock Cluster Set Rfid Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetRfidResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set User Status + * + * + * + * @param userId Ver.: always + * @param userStatus Ver.: always + */ +bool emberAfDoorLockClusterSetUserStatusCallback(uint16_t userId, uint8_t userStatus); +/** @brief Door Lock Cluster Set User Status Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetUserStatusResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set User Type + * + * + * + * @param userId Ver.: always + * @param userType Ver.: always + */ +bool emberAfDoorLockClusterSetUserTypeCallback(uint16_t userId, uint8_t userType); +/** @brief Door Lock Cluster Set User Type Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetUserTypeResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set Weekday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + * @param daysMask Ver.: always + * @param startHour Ver.: always + * @param startMinute Ver.: always + * @param endHour Ver.: always + * @param endMinute Ver.: always + */ +bool emberAfDoorLockClusterSetWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId, uint8_t daysMask, uint8_t startHour, + uint8_t startMinute, uint8_t endHour, uint8_t endMinute); +/** @brief Door Lock Cluster Set Weekday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetWeekdayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Set Yearday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + * @param localStartTime Ver.: always + * @param localEndTime Ver.: always + */ +bool emberAfDoorLockClusterSetYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId, uint32_t localStartTime, + uint32_t localEndTime); +/** @brief Door Lock Cluster Set Yearday Schedule Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterSetYeardayScheduleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Toggle + * + * + * + * @param pin Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterToggleCallback(uint8_t * pin); +/** @brief Door Lock Cluster Toggle Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterToggleResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Unlock Door + * + * + * + * @param PIN Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterUnlockDoorCallback(uint8_t * PIN); +/** @brief Door Lock Cluster Unlock Door Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterUnlockDoorResponseCallback(uint8_t status); +/** @brief Door Lock Cluster Unlock With Timeout + * + * + * + * @param timeoutInSeconds Ver.: always + * @param pin Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterUnlockWithTimeoutCallback(uint16_t timeoutInSeconds, uint8_t * pin); +/** @brief Door Lock Cluster Unlock With Timeout Response + * + * + * + * @param status Ver.: always + */ +bool emberAfDoorLockClusterUnlockWithTimeoutResponseCallback(uint8_t status); + +/** @} END Door Lock Cluster Callbacks */ + +/** @name Window Covering Cluster Callbacks */ +// @{ + +/** @brief Window Covering Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfWindowCoveringClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Window Covering Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfWindowCoveringClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Window Covering Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfWindowCoveringClusterClientInitCallback(uint8_t endpoint); +/** @brief Window Covering Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfWindowCoveringClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Window Covering Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfWindowCoveringClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Window Covering Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfWindowCoveringClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Window Covering Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfWindowCoveringClusterClientTickCallback(uint8_t endpoint); +/** @brief Window Covering Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfWindowCoveringClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Window Covering Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfWindowCoveringClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Window Covering Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfWindowCoveringClusterServerInitCallback(uint8_t endpoint); +/** @brief Window Covering Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfWindowCoveringClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Window Covering Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfWindowCoveringClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Window Covering Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfWindowCoveringClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Window Covering Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfWindowCoveringClusterServerTickCallback(uint8_t endpoint); +/** @brief Window Covering Cluster Window Covering Down Close + * + * + * + */ +bool emberAfWindowCoveringClusterWindowCoveringDownCloseCallback(void); +/** @brief Window Covering Cluster Window Covering Go To Lift Percentage + * + * + * + * @param percentageLiftValue Ver.: always + */ +bool emberAfWindowCoveringClusterWindowCoveringGoToLiftPercentageCallback(uint8_t percentageLiftValue); +/** @brief Window Covering Cluster Window Covering Go To Lift Value + * + * + * + * @param liftValue Ver.: always + */ +bool emberAfWindowCoveringClusterWindowCoveringGoToLiftValueCallback(uint16_t liftValue); +/** @brief Window Covering Cluster Window Covering Go To Tilt Percentage + * + * + * + * @param percentageTiltValue Ver.: always + */ +bool emberAfWindowCoveringClusterWindowCoveringGoToTiltPercentageCallback(uint8_t percentageTiltValue); +/** @brief Window Covering Cluster Window Covering Go To Tilt Value + * + * + * + * @param tiltValue Ver.: always + */ +bool emberAfWindowCoveringClusterWindowCoveringGoToTiltValueCallback(uint16_t tiltValue); +/** @brief Window Covering Cluster Window Covering Stop + * + * + * + */ +bool emberAfWindowCoveringClusterWindowCoveringStopCallback(void); +/** @brief Window Covering Cluster Window Covering Up Open + * + * + * + */ +bool emberAfWindowCoveringClusterWindowCoveringUpOpenCallback(void); + +/** @} END Window Covering Cluster Callbacks */ + +/** @name Barrier Control Cluster Callbacks */ +// @{ + +/** @brief Barrier Control Cluster Barrier Control Go To Percent + * + * + * + * @param percentOpen Ver.: always + */ +bool emberAfBarrierControlClusterBarrierControlGoToPercentCallback(uint8_t percentOpen); +/** @brief Barrier Control Cluster Barrier Control Stop + * + * + * + */ +bool emberAfBarrierControlClusterBarrierControlStopCallback(void); +/** @brief Barrier Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBarrierControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Barrier Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBarrierControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Barrier Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBarrierControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Barrier Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBarrierControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Barrier Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBarrierControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Barrier Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBarrierControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Barrier Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBarrierControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Barrier Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBarrierControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Barrier Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBarrierControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Barrier Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBarrierControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Barrier Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBarrierControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Barrier Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBarrierControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Barrier Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBarrierControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Barrier Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBarrierControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Barrier Control Cluster Callbacks */ + +/** @name Pump Configuration and Control Cluster Callbacks */ +// @{ + +/** @brief Pump Configuration and Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPumpConfigControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Pump Configuration and Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPumpConfigControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Pump Configuration and Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPumpConfigControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Pump Configuration and Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPumpConfigControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Pump Configuration and Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPumpConfigControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Pump Configuration and Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPumpConfigControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Pump Configuration and Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPumpConfigControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Pump Configuration and Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPumpConfigControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Pump Configuration and Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPumpConfigControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Pump Configuration and Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPumpConfigControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Pump Configuration and Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPumpConfigControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Pump Configuration and Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPumpConfigControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Pump Configuration and Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPumpConfigControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Pump Configuration and Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPumpConfigControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Pump Configuration and Control Cluster Callbacks */ + +/** @name Thermostat Cluster Callbacks */ +// @{ + +/** @brief Thermostat Cluster Clear Weekly Schedule + * + * + * + */ +bool emberAfThermostatClusterClearWeeklyScheduleCallback(void); +/** @brief Thermostat Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfThermostatClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Thermostat Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfThermostatClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Thermostat Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfThermostatClusterClientInitCallback(uint8_t endpoint); +/** @brief Thermostat Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfThermostatClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Thermostat Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfThermostatClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Thermostat Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfThermostatClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Thermostat Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfThermostatClusterClientTickCallback(uint8_t endpoint); +/** @brief Thermostat Cluster Current Weekly Schedule + * + * + * + * @param numberOfTransitionsForSequence Ver.: always + * @param dayOfWeekForSequence Ver.: always + * @param modeForSequence Ver.: always + * @param payload Ver.: always + */ +bool emberAfThermostatClusterCurrentWeeklyScheduleCallback(uint8_t numberOfTransitionsForSequence, uint8_t dayOfWeekForSequence, + uint8_t modeForSequence, uint8_t * payload); +/** @brief Thermostat Cluster Get Relay Status Log + * + * + * + */ +bool emberAfThermostatClusterGetRelayStatusLogCallback(void); +/** @brief Thermostat Cluster Get Weekly Schedule + * + * + * + * @param daysToReturn Ver.: always + * @param modeToReturn Ver.: always + */ +bool emberAfThermostatClusterGetWeeklyScheduleCallback(uint8_t daysToReturn, uint8_t modeToReturn); +/** @brief Thermostat Cluster Relay Status Log + * + * + * + * @param timeOfDay Ver.: always + * @param relayStatus Ver.: always + * @param localTemperature Ver.: always + * @param humidityInPercentage Ver.: always + * @param setpoint Ver.: always + * @param unreadEntries Ver.: always + */ +bool emberAfThermostatClusterRelayStatusLogCallback(uint16_t timeOfDay, uint16_t relayStatus, int16_t localTemperature, + uint8_t humidityInPercentage, int16_t setpoint, uint16_t unreadEntries); +/** @brief Thermostat Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfThermostatClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Thermostat Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfThermostatClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Thermostat Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfThermostatClusterServerInitCallback(uint8_t endpoint); +/** @brief Thermostat Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfThermostatClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Thermostat Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfThermostatClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Thermostat Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfThermostatClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Thermostat Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfThermostatClusterServerTickCallback(uint8_t endpoint); +/** @brief Thermostat Cluster Set Weekly Schedule + * + * + * + * @param numberOfTransitionsForSequence Ver.: always + * @param dayOfWeekForSequence Ver.: always + * @param modeForSequence Ver.: always + * @param payload Ver.: always + */ +bool emberAfThermostatClusterSetWeeklyScheduleCallback(uint8_t numberOfTransitionsForSequence, uint8_t dayOfWeekForSequence, + uint8_t modeForSequence, uint8_t * payload); +/** @brief Thermostat Cluster Setpoint Raise Lower + * + * + * + * @param mode Ver.: always + * @param amount Ver.: always + */ +bool emberAfThermostatClusterSetpointRaiseLowerCallback(uint8_t mode, int8_t amount); + +/** @} END Thermostat Cluster Callbacks */ + +/** @name Fan Control Cluster Callbacks */ +// @{ + +/** @brief Fan Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFanControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Fan Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFanControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Fan Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFanControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Fan Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFanControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Fan Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFanControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Fan Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFanControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Fan Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFanControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Fan Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFanControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Fan Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFanControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Fan Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFanControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Fan Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFanControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Fan Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFanControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Fan Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFanControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Fan Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFanControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Fan Control Cluster Callbacks */ + +/** @name Dehumidification Control Cluster Callbacks */ +// @{ + +/** @brief Dehumidification Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDehumidControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Dehumidification Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDehumidControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Dehumidification Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDehumidControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Dehumidification Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDehumidControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Dehumidification Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDehumidControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Dehumidification Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDehumidControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Dehumidification Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDehumidControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Dehumidification Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDehumidControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Dehumidification Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDehumidControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Dehumidification Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDehumidControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Dehumidification Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDehumidControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Dehumidification Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDehumidControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Dehumidification Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDehumidControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Dehumidification Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDehumidControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Dehumidification Control Cluster Callbacks */ + +/** @name Thermostat User Interface Configuration Cluster Callbacks */ +// @{ + +/** @brief Thermostat User Interface Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfThermostatUiConfigClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Thermostat User Interface Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfThermostatUiConfigClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Thermostat User Interface Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfThermostatUiConfigClusterClientInitCallback(uint8_t endpoint); +/** @brief Thermostat User Interface Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfThermostatUiConfigClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Thermostat User Interface Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfThermostatUiConfigClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Thermostat User Interface Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfThermostatUiConfigClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Thermostat User Interface Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfThermostatUiConfigClusterClientTickCallback(uint8_t endpoint); +/** @brief Thermostat User Interface Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfThermostatUiConfigClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Thermostat User Interface Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfThermostatUiConfigClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Thermostat User Interface Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfThermostatUiConfigClusterServerInitCallback(uint8_t endpoint); +/** @brief Thermostat User Interface Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfThermostatUiConfigClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Thermostat User Interface Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfThermostatUiConfigClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Thermostat User Interface Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfThermostatUiConfigClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Thermostat User Interface Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfThermostatUiConfigClusterServerTickCallback(uint8_t endpoint); + +/** @} END Thermostat User Interface Configuration Cluster Callbacks */ + +/** @name Color Control Cluster Callbacks */ +// @{ + +/** @brief Color Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfColorControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Color Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfColorControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Color Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfColorControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Color Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfColorControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Color Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfColorControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Color Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfColorControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Color Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfColorControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Color Control Cluster Color Loop Set + * + * + * + * @param updateFlags Ver.: always + * @param action Ver.: always + * @param direction Ver.: always + * @param time Ver.: always + * @param startHue Ver.: always + */ +bool emberAfColorControlClusterColorLoopSetCallback(uint8_t updateFlags, uint8_t action, uint8_t direction, uint16_t time, + uint16_t startHue); +/** @brief Color Control Cluster Enhanced Move Hue + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + */ +bool emberAfColorControlClusterEnhancedMoveHueCallback(uint8_t moveMode, uint16_t rate); +/** @brief Color Control Cluster Enhanced Move To Hue And Saturation + * + * + * + * @param enhancedHue Ver.: always + * @param saturation Ver.: always + * @param transitionTime Ver.: always + */ +bool emberAfColorControlClusterEnhancedMoveToHueAndSaturationCallback(uint16_t enhancedHue, uint8_t saturation, + uint16_t transitionTime); +/** @brief Color Control Cluster Enhanced Move To Hue + * + * + * + * @param enhancedHue Ver.: always + * @param direction Ver.: always + * @param transitionTime Ver.: always + */ +bool emberAfColorControlClusterEnhancedMoveToHueCallback(uint16_t enhancedHue, uint8_t direction, uint16_t transitionTime); +/** @brief Color Control Cluster Enhanced Step Hue + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + */ +bool emberAfColorControlClusterEnhancedStepHueCallback(uint8_t stepMode, uint16_t stepSize, uint16_t transitionTime); +/** @brief Color Control Cluster Move Color + * + * + * + * @param rateX Ver.: always + * @param rateY Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveColorCallback(int16_t rateX, int16_t rateY, uint8_t optionsMask, uint8_t optionsOverride); +/** @brief Color Control Cluster Move Color Temperature + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + * @param colorTemperatureMinimum Ver.: always + * @param colorTemperatureMaximum Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveColorTemperatureCallback(uint8_t moveMode, uint16_t rate, uint16_t colorTemperatureMinimum, + uint16_t colorTemperatureMaximum, uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move Hue + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveHueCallback(uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride); +/** @brief Color Control Cluster Move Saturation + * + * + * + * @param moveMode Ver.: always + * @param rate Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveSaturationCallback(uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride); +/** @brief Color Control Cluster Move To Color + * + * + * + * @param colorX Ver.: always + * @param colorY Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveToColorCallback(uint16_t colorX, uint16_t colorY, uint16_t transitionTime, uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move To Color Temperature + * + * + * + * @param colorTemperature Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveToColorTemperatureCallback(uint16_t colorTemperature, uint16_t transitionTime, + uint8_t optionsMask, uint8_t optionsOverride); +/** @brief Color Control Cluster Move To Hue And Saturation + * + * + * + * @param hue Ver.: always + * @param saturation Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveToHueAndSaturationCallback(uint8_t hue, uint8_t saturation, uint16_t transitionTime, + uint8_t optionsMask, uint8_t optionsOverride); +/** @brief Color Control Cluster Move To Hue + * + * + * + * @param hue Ver.: always + * @param direction Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveToHueCallback(uint8_t hue, uint8_t direction, uint16_t transitionTime, uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Move To Saturation + * + * + * + * @param saturation Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterMoveToSaturationCallback(uint8_t saturation, uint16_t transitionTime, uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfColorControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Color Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfColorControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Color Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfColorControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Color Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfColorControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Color Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfColorControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Color Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfColorControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Color Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfColorControlClusterServerTickCallback(uint8_t endpoint); +/** @brief Color Control Cluster Step Color + * + * + * + * @param stepX Ver.: always + * @param stepY Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterStepColorCallback(int16_t stepX, int16_t stepY, uint16_t transitionTime, uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Step Color Temperature + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + * @param colorTemperatureMinimum Ver.: always + * @param colorTemperatureMaximum Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterStepColorTemperatureCallback(uint8_t stepMode, uint16_t stepSize, uint16_t transitionTime, + uint16_t colorTemperatureMinimum, uint16_t colorTemperatureMaximum, + uint8_t optionsMask, uint8_t optionsOverride); +/** @brief Color Control Cluster Step Hue + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterStepHueCallback(uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime, uint8_t optionsMask, + uint8_t optionsOverride); +/** @brief Color Control Cluster Step Saturation + * + * + * + * @param stepMode Ver.: always + * @param stepSize Ver.: always + * @param transitionTime Ver.: always + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterStepSaturationCallback(uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime, + uint8_t optionsMask, uint8_t optionsOverride); +/** @brief Color Control Cluster Stop Move Step + * + * + * + * @param optionsMask Ver.: since zcl6-errata-14-0129-15 + * @param optionsOverride Ver.: since zcl6-errata-14-0129-15 + */ +bool emberAfColorControlClusterStopMoveStepCallback(uint8_t optionsMask, uint8_t optionsOverride); + +/** @} END Color Control Cluster Callbacks */ + +/** @name Ballast Configuration Cluster Callbacks */ +// @{ + +/** @brief Ballast Configuration Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBallastConfigurationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Ballast Configuration Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBallastConfigurationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Ballast Configuration Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBallastConfigurationClusterClientInitCallback(uint8_t endpoint); +/** @brief Ballast Configuration Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBallastConfigurationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ballast Configuration Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBallastConfigurationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Ballast Configuration Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBallastConfigurationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Ballast Configuration Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBallastConfigurationClusterClientTickCallback(uint8_t endpoint); +/** @brief Ballast Configuration Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBallastConfigurationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Ballast Configuration Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBallastConfigurationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Ballast Configuration Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBallastConfigurationClusterServerInitCallback(uint8_t endpoint); +/** @brief Ballast Configuration Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBallastConfigurationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ballast Configuration Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBallastConfigurationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Ballast Configuration Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBallastConfigurationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Ballast Configuration Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBallastConfigurationClusterServerTickCallback(uint8_t endpoint); + +/** @} END Ballast Configuration Cluster Callbacks */ + +/** @name Illuminance Measurement Cluster Callbacks */ +// @{ + +/** @brief Illuminance Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIllumMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Illuminance Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIllumMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Illuminance Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIllumMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Illuminance Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIllumMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Illuminance Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIllumMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Illuminance Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIllumMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Illuminance Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIllumMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Illuminance Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIllumMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Illuminance Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIllumMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Illuminance Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIllumMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Illuminance Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIllumMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Illuminance Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIllumMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Illuminance Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIllumMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Illuminance Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIllumMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Illuminance Measurement Cluster Callbacks */ + +/** @name Illuminance Level Sensing Cluster Callbacks */ +// @{ + +/** @brief Illuminance Level Sensing Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIllumLevelSensingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Illuminance Level Sensing Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIllumLevelSensingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Illuminance Level Sensing Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIllumLevelSensingClusterClientInitCallback(uint8_t endpoint); +/** @brief Illuminance Level Sensing Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIllumLevelSensingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Illuminance Level Sensing Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIllumLevelSensingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Illuminance Level Sensing Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIllumLevelSensingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Illuminance Level Sensing Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIllumLevelSensingClusterClientTickCallback(uint8_t endpoint); +/** @brief Illuminance Level Sensing Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIllumLevelSensingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Illuminance Level Sensing Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIllumLevelSensingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Illuminance Level Sensing Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIllumLevelSensingClusterServerInitCallback(uint8_t endpoint); +/** @brief Illuminance Level Sensing Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIllumLevelSensingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Illuminance Level Sensing Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIllumLevelSensingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Illuminance Level Sensing Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIllumLevelSensingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Illuminance Level Sensing Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIllumLevelSensingClusterServerTickCallback(uint8_t endpoint); + +/** @} END Illuminance Level Sensing Cluster Callbacks */ + +/** @name Temperature Measurement Cluster Callbacks */ +// @{ + +/** @brief Temperature Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTempMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Temperature Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTempMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Temperature Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTempMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Temperature Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTempMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Temperature Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTempMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Temperature Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTempMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Temperature Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTempMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Temperature Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTempMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Temperature Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTempMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Temperature Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTempMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Temperature Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTempMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Temperature Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTempMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Temperature Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTempMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Temperature Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTempMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Temperature Measurement Cluster Callbacks */ + +/** @name Pressure Measurement Cluster Callbacks */ +// @{ + +/** @brief Pressure Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPressureMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Pressure Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPressureMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Pressure Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPressureMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Pressure Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPressureMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Pressure Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPressureMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Pressure Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPressureMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Pressure Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPressureMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Pressure Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPressureMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Pressure Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPressureMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Pressure Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPressureMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Pressure Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPressureMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Pressure Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPressureMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Pressure Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPressureMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Pressure Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPressureMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Pressure Measurement Cluster Callbacks */ + +/** @name Flow Measurement Cluster Callbacks */ +// @{ + +/** @brief Flow Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFlowMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Flow Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFlowMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Flow Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFlowMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Flow Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFlowMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Flow Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFlowMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Flow Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFlowMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Flow Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFlowMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Flow Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFlowMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Flow Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFlowMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Flow Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFlowMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Flow Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFlowMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Flow Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFlowMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Flow Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFlowMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Flow Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFlowMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Flow Measurement Cluster Callbacks */ + +/** @name Relative Humidity Measurement Cluster Callbacks */ +// @{ + +/** @brief Relative Humidity Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Relative Humidity Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Relative Humidity Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Relative Humidity Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Relative Humidity Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Relative Humidity Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfRelativeHumidityMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Relative Humidity Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Relative Humidity Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Relative Humidity Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Relative Humidity Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Relative Humidity Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Relative Humidity Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Relative Humidity Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfRelativeHumidityMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Relative Humidity Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfRelativeHumidityMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Relative Humidity Measurement Cluster Callbacks */ + +/** @name Occupancy Sensing Cluster Callbacks */ +// @{ + +/** @brief Occupancy Sensing Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOccupancySensingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Occupancy Sensing Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOccupancySensingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Occupancy Sensing Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOccupancySensingClusterClientInitCallback(uint8_t endpoint); +/** @brief Occupancy Sensing Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOccupancySensingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Occupancy Sensing Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOccupancySensingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Occupancy Sensing Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOccupancySensingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Occupancy Sensing Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOccupancySensingClusterClientTickCallback(uint8_t endpoint); +/** @brief Occupancy Sensing Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOccupancySensingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Occupancy Sensing Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOccupancySensingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Occupancy Sensing Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOccupancySensingClusterServerInitCallback(uint8_t endpoint); +/** @brief Occupancy Sensing Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOccupancySensingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Occupancy Sensing Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOccupancySensingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Occupancy Sensing Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOccupancySensingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Occupancy Sensing Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOccupancySensingClusterServerTickCallback(uint8_t endpoint); + +/** @} END Occupancy Sensing Cluster Callbacks */ + +/** @name Carbon Monoxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCarbonMonoxideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Carbon Monoxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCarbonMonoxideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Carbon Monoxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCarbonMonoxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Carbon Monoxide Concentration Measurement Cluster Callbacks */ + +/** @name Carbon Dioxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCarbonDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Carbon Dioxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCarbonDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Carbon Dioxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCarbonDioxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Carbon Dioxide Concentration Measurement Cluster Callbacks */ + +/** @name Ethylene Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Ethylene Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Ethylene Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Ethylene Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Ethylene Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Ethylene Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Ethylene Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEthyleneConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Ethylene Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Ethylene Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Ethylene Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Ethylene Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Ethylene Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Ethylene Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Ethylene Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEthyleneConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Ethylene Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEthyleneConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Ethylene Concentration Measurement Cluster Callbacks */ + +/** @name Ethylene Oxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEthyleneOxideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Ethylene Oxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEthyleneOxideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Ethylene Oxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEthyleneOxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Ethylene Oxide Concentration Measurement Cluster Callbacks */ + +/** @name Hydrogen Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Hydrogen Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Hydrogen Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Hydrogen Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Hydrogen Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Hydrogen Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Hydrogen Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHydrogenConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Hydrogen Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Hydrogen Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Hydrogen Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Hydrogen Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Hydrogen Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Hydrogen Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Hydrogen Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHydrogenConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Hydrogen Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHydrogenConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Hydrogen Concentration Measurement Cluster Callbacks */ + +/** @name Hydrogen Sulphide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHydrogenSulphideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHydrogenSulphideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Hydrogen Sulphide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHydrogenSulphideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Hydrogen Sulphide Concentration Measurement Cluster Callbacks */ + +/** @name Nitric Oxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Nitric Oxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfNitricOxideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Nitric Oxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfNitricOxideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Nitric Oxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfNitricOxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Nitric Oxide Concentration Measurement Cluster Callbacks */ + +/** @name Nitrogen Dioxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfNitrogenDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfNitrogenDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Nitrogen Dioxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfNitrogenDioxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Nitrogen Dioxide Concentration Measurement Cluster Callbacks */ + +/** @name Oxygen Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Oxygen Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Oxygen Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Oxygen Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Oxygen Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Oxygen Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Oxygen Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOxygenConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Oxygen Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Oxygen Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Oxygen Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Oxygen Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Oxygen Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Oxygen Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Oxygen Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOxygenConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Oxygen Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOxygenConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Oxygen Concentration Measurement Cluster Callbacks */ + +/** @name Ozone Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Ozone Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Ozone Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Ozone Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Ozone Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ozone Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Ozone Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOzoneConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Ozone Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Ozone Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Ozone Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Ozone Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Ozone Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Ozone Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Ozone Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOzoneConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Ozone Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOzoneConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Ozone Concentration Measurement Cluster Callbacks */ + +/** @name Sulfur Dioxide Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSulfurDioxideConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSulfurDioxideConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Sulfur Dioxide Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSulfurDioxideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Sulfur Dioxide Concentration Measurement Cluster Callbacks */ + +/** @name Dissolved Oxygen Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDissolvedOxygenConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDissolvedOxygenConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Dissolved Oxygen Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDissolvedOxygenConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Dissolved Oxygen Concentration Measurement Cluster Callbacks */ + +/** @name Bromate Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Bromate Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Bromate Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Bromate Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Bromate Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Bromate Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Bromate Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromateConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Bromate Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Bromate Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Bromate Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Bromate Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Bromate Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Bromate Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Bromate Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromateConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Bromate Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromateConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Bromate Concentration Measurement Cluster Callbacks */ + +/** @name Chloramines Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Chloramines Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chloramines Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Chloramines Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Chloramines Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Chloramines Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Chloramines Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChloraminesConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Chloramines Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Chloramines Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chloramines Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Chloramines Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Chloramines Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Chloramines Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Chloramines Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChloraminesConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Chloramines Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChloraminesConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Chloramines Concentration Measurement Cluster Callbacks */ + +/** @name Chlorine Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Chlorine Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Chlorine Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Chlorine Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Chlorine Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Chlorine Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Chlorine Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChlorineConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Chlorine Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Chlorine Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Chlorine Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Chlorine Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Chlorine Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Chlorine Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Chlorine Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChlorineConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Chlorine Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChlorineConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Chlorine Concentration Measurement Cluster Callbacks */ + +/** @name Fecal coliform and E. Coli Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Fecal coliform and E. Coli Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFecalColiformAndEColiConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Fecal coliform and E. Coli Concentration Measurement Cluster Callbacks */ + +/** @name Fluoride Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Fluoride Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Fluoride Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Fluoride Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Fluoride Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Fluoride Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Fluoride Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFluorideConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Fluoride Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Fluoride Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Fluoride Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Fluoride Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Fluoride Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Fluoride Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Fluoride Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfFluorideConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Fluoride Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfFluorideConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Fluoride Concentration Measurement Cluster Callbacks */ + +/** @name Haloacetic Acids Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHaloaceticAcidsConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Haloacetic Acids Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfHaloaceticAcidsConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Haloacetic Acids Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfHaloaceticAcidsConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Haloacetic Acids Concentration Measurement Cluster Callbacks */ + +/** @name Total Trihalomethanes Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Total Trihalomethanes Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTotalTrihalomethanesConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Total Trihalomethanes Concentration Measurement Cluster Callbacks */ + +/** @name Total Coliform Bacteria Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Total Coliform Bacteria Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTotalColiformBacteriaConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Total Coliform Bacteria Concentration Measurement Cluster Callbacks */ + +/** @name Turbidity Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Turbidity Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Turbidity Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Turbidity Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Turbidity Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Turbidity Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Turbidity Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTurbidityConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Turbidity Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Turbidity Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Turbidity Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Turbidity Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Turbidity Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Turbidity Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Turbidity Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTurbidityConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Turbidity Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTurbidityConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Turbidity Concentration Measurement Cluster Callbacks */ + +/** @name Copper Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Copper Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Copper Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Copper Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Copper Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Copper Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Copper Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCopperConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Copper Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Copper Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Copper Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Copper Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Copper Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Copper Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Copper Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCopperConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Copper Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCopperConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Copper Concentration Measurement Cluster Callbacks */ + +/** @name Lead Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Lead Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Lead Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Lead Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Lead Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Lead Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Lead Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfLeadConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Lead Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Lead Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Lead Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Lead Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Lead Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Lead Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Lead Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfLeadConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Lead Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfLeadConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Lead Concentration Measurement Cluster Callbacks */ + +/** @name Manganese Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Manganese Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Manganese Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Manganese Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Manganese Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Manganese Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Manganese Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfManganeseConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Manganese Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Manganese Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Manganese Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Manganese Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Manganese Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Manganese Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Manganese Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfManganeseConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Manganese Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfManganeseConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Manganese Concentration Measurement Cluster Callbacks */ + +/** @name Sulfate Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Sulfate Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Sulfate Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Sulfate Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Sulfate Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sulfate Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Sulfate Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSulfateConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Sulfate Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Sulfate Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Sulfate Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Sulfate Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Sulfate Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sulfate Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Sulfate Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSulfateConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Sulfate Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSulfateConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Sulfate Concentration Measurement Cluster Callbacks */ + +/** @name Bromodichloromethane Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromodichloromethaneConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Bromodichloromethane Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromodichloromethaneConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Bromodichloromethane Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromodichloromethaneConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Bromodichloromethane Concentration Measurement Cluster Callbacks */ + +/** @name Bromoform Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Bromoform Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Bromoform Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Bromoform Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Bromoform Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Bromoform Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Bromoform Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromoformConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Bromoform Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Bromoform Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Bromoform Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Bromoform Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Bromoform Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Bromoform Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Bromoform Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBromoformConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Bromoform Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBromoformConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Bromoform Concentration Measurement Cluster Callbacks */ + +/** @name Chlorodibromomethane Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChlorodibromomethaneConcentrationMeasurementClusterClientPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChlorodibromomethaneConcentrationMeasurementClusterServerPreAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, EmberAfAttributeType attributeType, uint8_t size, uint8_t * value); +/** @brief Chlorodibromomethane Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChlorodibromomethaneConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Chlorodibromomethane Concentration Measurement Cluster Callbacks */ + +/** @name Chloroform Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Chloroform Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chloroform Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Chloroform Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Chloroform Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Chloroform Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Chloroform Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChloroformConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Chloroform Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Chloroform Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId); +/** @brief Chloroform Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Chloroform Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Chloroform Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback( + uint8_t endpoint, EmberAfAttributeId attributeId, uint16_t manufacturerCode); +/** @brief Chloroform Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, + uint8_t * message, EmberStatus status); +/** @brief Chloroform Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChloroformConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Chloroform Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChloroformConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Chloroform Concentration Measurement Cluster Callbacks */ + +/** @name Sodium Concentration Measurement Cluster Callbacks */ +// @{ + +/** @brief Sodium Concentration Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Sodium Concentration Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Sodium Concentration Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Sodium Concentration Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sodium Concentration Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Sodium Concentration Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSodiumConcentrationMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Sodium Concentration Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Sodium Concentration Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Sodium Concentration Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Sodium Concentration Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Sodium Concentration Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sodium Concentration Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, + uint16_t indexOrDestination, EmberApsFrame * apsFrame, + uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Sodium Concentration Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSodiumConcentrationMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Sodium Concentration Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSodiumConcentrationMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Sodium Concentration Measurement Cluster Callbacks */ + +/** @name IAS Zone Cluster Callbacks */ +// @{ + +/** @brief IAS Zone Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasZoneClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief IAS Zone Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasZoneClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief IAS Zone Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasZoneClusterClientInitCallback(uint8_t endpoint); +/** @brief IAS Zone Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasZoneClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS Zone Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasZoneClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief IAS Zone Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasZoneClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief IAS Zone Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasZoneClusterClientTickCallback(uint8_t endpoint); +/** @brief IAS Zone Cluster Initiate Normal Operation Mode + * + * + * + */ +bool emberAfIasZoneClusterInitiateNormalOperationModeCallback(void); +/** @brief IAS Zone Cluster Initiate Normal Operation Mode Response + * + * + * + */ +bool emberAfIasZoneClusterInitiateNormalOperationModeResponseCallback(void); +/** @brief IAS Zone Cluster Initiate Test Mode + * + * + * + * @param testModeDuration Ver.: always + * @param currentZoneSensitivityLevel Ver.: always + */ +bool emberAfIasZoneClusterInitiateTestModeCallback(uint8_t testModeDuration, uint8_t currentZoneSensitivityLevel); +/** @brief IAS Zone Cluster Initiate Test Mode Response + * + * + * + */ +bool emberAfIasZoneClusterInitiateTestModeResponseCallback(void); +/** @brief IAS Zone Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasZoneClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief IAS Zone Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasZoneClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief IAS Zone Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasZoneClusterServerInitCallback(uint8_t endpoint); +/** @brief IAS Zone Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasZoneClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS Zone Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasZoneClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief IAS Zone Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasZoneClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief IAS Zone Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasZoneClusterServerTickCallback(uint8_t endpoint); +/** @brief IAS Zone Cluster Zone Enroll Request + * + * + * + * @param zoneType Ver.: always + * @param manufacturerCode Ver.: always + */ +bool emberAfIasZoneClusterZoneEnrollRequestCallback(uint16_t zoneType, uint16_t manufacturerCode); +/** @brief IAS Zone Cluster Zone Enroll Response + * + * + * + * @param enrollResponseCode Ver.: always + * @param zoneId Ver.: always + */ +bool emberAfIasZoneClusterZoneEnrollResponseCallback(uint8_t enrollResponseCode, uint8_t zoneId); +/** @brief IAS Zone Cluster Zone Status Change Notification + * + * + * + * @param zoneStatus Ver.: always + * @param extendedStatus Ver.: always + * @param zoneId Ver.: since ha-1.2-05-3520-29 + * @param delay Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfIasZoneClusterZoneStatusChangeNotificationCallback(uint16_t zoneStatus, uint8_t extendedStatus, uint8_t zoneId, + uint16_t delay); + +/** @} END IAS Zone Cluster Callbacks */ + +/** @name IAS ACE Cluster Callbacks */ +// @{ + +/** @brief IAS ACE Cluster Arm + * + * + * + * @param armMode Ver.: always + * @param armDisarmCode Ver.: since ha-1.2-05-3520-29 + * @param zoneId Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfIasAceClusterArmCallback(uint8_t armMode, uint8_t * armDisarmCode, uint8_t zoneId); +/** @brief IAS ACE Cluster Arm Response + * + * + * + * @param armNotification Ver.: always + */ +bool emberAfIasAceClusterArmResponseCallback(uint8_t armNotification); +/** @brief IAS ACE Cluster Bypass + * + * + * + * @param numberOfZones Ver.: always + * @param zoneIds Ver.: always + * @param armDisarmCode Ver.: since ha-1.2.1-05-3520-30 + */ +bool emberAfIasAceClusterBypassCallback(uint8_t numberOfZones, uint8_t * zoneIds, uint8_t * armDisarmCode); +/** @brief IAS ACE Cluster Bypass Response + * + * + * + * @param numberOfZones Ver.: always + * @param bypassResult Ver.: always + */ +bool emberAfIasAceClusterBypassResponseCallback(uint8_t numberOfZones, uint8_t * bypassResult); +/** @brief IAS ACE Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasAceClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief IAS ACE Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasAceClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief IAS ACE Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasAceClusterClientInitCallback(uint8_t endpoint); +/** @brief IAS ACE Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasAceClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS ACE Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasAceClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief IAS ACE Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasAceClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief IAS ACE Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasAceClusterClientTickCallback(uint8_t endpoint); +/** @brief IAS ACE Cluster Emergency + * + * + * + */ +bool emberAfIasAceClusterEmergencyCallback(void); +/** @brief IAS ACE Cluster Fire + * + * + * + */ +bool emberAfIasAceClusterFireCallback(void); +/** @brief IAS ACE Cluster Get Bypassed Zone List + * + * + * + */ +bool emberAfIasAceClusterGetBypassedZoneListCallback(void); +/** @brief IAS ACE Cluster Get Panel Status + * + * + * + */ +bool emberAfIasAceClusterGetPanelStatusCallback(void); +/** @brief IAS ACE Cluster Get Panel Status Response + * + * + * + * @param panelStatus Ver.: always + * @param secondsRemaining Ver.: always + * @param audibleNotification Ver.: always + * @param alarmStatus Ver.: always + */ +bool emberAfIasAceClusterGetPanelStatusResponseCallback(uint8_t panelStatus, uint8_t secondsRemaining, uint8_t audibleNotification, + uint8_t alarmStatus); +/** @brief IAS ACE Cluster Get Zone Id Map + * + * + * + */ +bool emberAfIasAceClusterGetZoneIdMapCallback(void); +/** @brief IAS ACE Cluster Get Zone Id Map Response + * + * + * + * @param section0 Ver.: always + * @param section1 Ver.: always + * @param section2 Ver.: always + * @param section3 Ver.: always + * @param section4 Ver.: always + * @param section5 Ver.: always + * @param section6 Ver.: always + * @param section7 Ver.: always + * @param section8 Ver.: always + * @param section9 Ver.: always + * @param section10 Ver.: always + * @param section11 Ver.: always + * @param section12 Ver.: always + * @param section13 Ver.: always + * @param section14 Ver.: always + * @param section15 Ver.: always + */ +bool emberAfIasAceClusterGetZoneIdMapResponseCallback(uint16_t section0, uint16_t section1, uint16_t section2, uint16_t section3, + uint16_t section4, uint16_t section5, uint16_t section6, uint16_t section7, + uint16_t section8, uint16_t section9, uint16_t section10, uint16_t section11, + uint16_t section12, uint16_t section13, uint16_t section14, + uint16_t section15); +/** @brief IAS ACE Cluster Get Zone Information + * + * + * + * @param zoneId Ver.: always + */ +bool emberAfIasAceClusterGetZoneInformationCallback(uint8_t zoneId); +/** @brief IAS ACE Cluster Get Zone Information Response + * + * + * + * @param zoneId Ver.: always + * @param zoneType Ver.: always + * @param ieeeAddress Ver.: always + * @param zoneLabel Ver.: since ha-1.2.1-05-3520-30 + */ +bool emberAfIasAceClusterGetZoneInformationResponseCallback(uint8_t zoneId, uint16_t zoneType, uint8_t * ieeeAddress, + uint8_t * zoneLabel); +/** @brief IAS ACE Cluster Get Zone Status + * + * + * + * @param startingZoneId Ver.: always + * @param maxNumberOfZoneIds Ver.: always + * @param zoneStatusMaskFlag Ver.: always + * @param zoneStatusMask Ver.: always + */ +bool emberAfIasAceClusterGetZoneStatusCallback(uint8_t startingZoneId, uint8_t maxNumberOfZoneIds, uint8_t zoneStatusMaskFlag, + uint16_t zoneStatusMask); +/** @brief IAS ACE Cluster Get Zone Status Response + * + * + * + * @param zoneStatusComplete Ver.: always + * @param numberOfZones Ver.: always + * @param zoneStatusResult Ver.: always + */ +bool emberAfIasAceClusterGetZoneStatusResponseCallback(uint8_t zoneStatusComplete, uint8_t numberOfZones, + uint8_t * zoneStatusResult); +/** @brief IAS ACE Cluster Panel Status Changed + * + * + * + * @param panelStatus Ver.: always + * @param secondsRemaining Ver.: always + * @param audibleNotification Ver.: since ha-1.2.1-05-3520-30 + * @param alarmStatus Ver.: since ha-1.2.1-05-3520-30 + */ +bool emberAfIasAceClusterPanelStatusChangedCallback(uint8_t panelStatus, uint8_t secondsRemaining, uint8_t audibleNotification, + uint8_t alarmStatus); +/** @brief IAS ACE Cluster Panic + * + * + * + */ +bool emberAfIasAceClusterPanicCallback(void); +/** @brief IAS ACE Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasAceClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief IAS ACE Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasAceClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief IAS ACE Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasAceClusterServerInitCallback(uint8_t endpoint); +/** @brief IAS ACE Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasAceClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS ACE Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasAceClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief IAS ACE Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasAceClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief IAS ACE Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasAceClusterServerTickCallback(uint8_t endpoint); +/** @brief IAS ACE Cluster Set Bypassed Zone List + * + * + * + * @param numberOfZones Ver.: always + * @param zoneIds Ver.: always + */ +bool emberAfIasAceClusterSetBypassedZoneListCallback(uint8_t numberOfZones, uint8_t * zoneIds); +/** @brief IAS ACE Cluster Zone Status Changed + * + * + * + * @param zoneId Ver.: always + * @param zoneStatus Ver.: always + * @param audibleNotification Ver.: since ha-1.2.1-05-3520-30 + * @param zoneLabel Ver.: since ha-1.2.1-05-3520-30 + */ +bool emberAfIasAceClusterZoneStatusChangedCallback(uint8_t zoneId, uint16_t zoneStatus, uint8_t audibleNotification, + uint8_t * zoneLabel); + +/** @} END IAS ACE Cluster Callbacks */ + +/** @name IAS WD Cluster Callbacks */ +// @{ + +/** @brief IAS WD Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasWdClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief IAS WD Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasWdClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief IAS WD Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasWdClusterClientInitCallback(uint8_t endpoint); +/** @brief IAS WD Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasWdClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS WD Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasWdClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief IAS WD Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasWdClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief IAS WD Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasWdClusterClientTickCallback(uint8_t endpoint); +/** @brief IAS WD Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIasWdClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief IAS WD Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIasWdClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief IAS WD Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIasWdClusterServerInitCallback(uint8_t endpoint); +/** @brief IAS WD Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIasWdClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief IAS WD Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIasWdClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief IAS WD Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIasWdClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief IAS WD Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIasWdClusterServerTickCallback(uint8_t endpoint); +/** @brief IAS WD Cluster Squawk + * + * + * + * @param squawkInfo Ver.: always + */ +bool emberAfIasWdClusterSquawkCallback(uint8_t squawkInfo); +/** @brief IAS WD Cluster Start Warning + * + * + * + * @param warningInfo Ver.: always + * @param warningDuration Ver.: always + * @param strobeDutyCycle Ver.: since ha-1.2-05-3520-29 + * @param strobeLevel Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfIasWdClusterStartWarningCallback(uint8_t warningInfo, uint16_t warningDuration, uint8_t strobeDutyCycle, + uint8_t strobeLevel); + +/** @} END IAS WD Cluster Callbacks */ + +/** @name Generic Tunnel Cluster Callbacks */ +// @{ + +/** @brief Generic Tunnel Cluster Advertise Protocol Address + * + * + * + * @param protocolAddress Ver.: always + */ +bool emberAfGenericTunnelClusterAdvertiseProtocolAddressCallback(uint8_t * protocolAddress); +/** @brief Generic Tunnel Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGenericTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Generic Tunnel Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGenericTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Generic Tunnel Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGenericTunnelClusterClientInitCallback(uint8_t endpoint); +/** @brief Generic Tunnel Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGenericTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Generic Tunnel Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGenericTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Generic Tunnel Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGenericTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Generic Tunnel Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGenericTunnelClusterClientTickCallback(uint8_t endpoint); +/** @brief Generic Tunnel Cluster Match Protocol Address + * + * + * + * @param protocolAddress Ver.: always + */ +bool emberAfGenericTunnelClusterMatchProtocolAddressCallback(uint8_t * protocolAddress); +/** @brief Generic Tunnel Cluster Match Protocol Address Response + * + * + * + * @param deviceIeeeAddress Ver.: always + * @param protocolAddress Ver.: always + */ +bool emberAfGenericTunnelClusterMatchProtocolAddressResponseCallback(uint8_t * deviceIeeeAddress, uint8_t * protocolAddress); +/** @brief Generic Tunnel Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGenericTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Generic Tunnel Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGenericTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Generic Tunnel Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGenericTunnelClusterServerInitCallback(uint8_t endpoint); +/** @brief Generic Tunnel Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGenericTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Generic Tunnel Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGenericTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Generic Tunnel Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGenericTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Generic Tunnel Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGenericTunnelClusterServerTickCallback(uint8_t endpoint); + +/** @} END Generic Tunnel Cluster Callbacks */ + +/** @name BACnet Protocol Tunnel Cluster Callbacks */ +// @{ + +/** @brief BACnet Protocol Tunnel Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief BACnet Protocol Tunnel Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief BACnet Protocol Tunnel Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientInitCallback(uint8_t endpoint); +/** @brief BACnet Protocol Tunnel Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief BACnet Protocol Tunnel Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief BACnet Protocol Tunnel Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBacnetProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief BACnet Protocol Tunnel Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterClientTickCallback(uint8_t endpoint); +/** @brief BACnet Protocol Tunnel Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief BACnet Protocol Tunnel Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief BACnet Protocol Tunnel Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerInitCallback(uint8_t endpoint); +/** @brief BACnet Protocol Tunnel Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief BACnet Protocol Tunnel Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief BACnet Protocol Tunnel Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBacnetProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief BACnet Protocol Tunnel Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBacnetProtocolTunnelClusterServerTickCallback(uint8_t endpoint); +/** @brief BACnet Protocol Tunnel Cluster Transfer Npdu + * + * + * + * @param npdu Ver.: always + */ +bool emberAfBacnetProtocolTunnelClusterTransferNpduCallback(uint8_t * npdu); + +/** @} END BACnet Protocol Tunnel Cluster Callbacks */ + +/** @name 11073 Protocol Tunnel Cluster Callbacks */ +// @{ + +/** @brief 11073 Protocol Tunnel Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief 11073 Protocol Tunnel Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief 11073 Protocol Tunnel Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientInitCallback(uint8_t endpoint); +/** @brief 11073 Protocol Tunnel Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief 11073 Protocol Tunnel Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief 11073 Protocol Tunnel Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAf11073ProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief 11073 Protocol Tunnel Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAf11073ProtocolTunnelClusterClientTickCallback(uint8_t endpoint); +/** @brief 11073 Protocol Tunnel Cluster Connect Request + * + * + * + * @param connectControl Ver.: always + * @param idleTimeout Ver.: always + * @param managerTarget Ver.: always + * @param managerEndpoint Ver.: always + */ +bool emberAf11073ProtocolTunnelClusterConnectRequestCallback(uint8_t connectControl, uint16_t idleTimeout, uint8_t * managerTarget, + uint8_t managerEndpoint); +/** @brief 11073 Protocol Tunnel Cluster Connect Status Notification + * + * + * + * @param connectStatus Ver.: always + */ +bool emberAf11073ProtocolTunnelClusterConnectStatusNotificationCallback(uint8_t connectStatus); +/** @brief 11073 Protocol Tunnel Cluster Disconnect Request + * + * + * + * @param managerIEEEAddress Ver.: always + */ +bool emberAf11073ProtocolTunnelClusterDisconnectRequestCallback(uint8_t * managerIEEEAddress); +/** @brief 11073 Protocol Tunnel Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief 11073 Protocol Tunnel Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief 11073 Protocol Tunnel Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerInitCallback(uint8_t endpoint); +/** @brief 11073 Protocol Tunnel Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief 11073 Protocol Tunnel Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief 11073 Protocol Tunnel Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAf11073ProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief 11073 Protocol Tunnel Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAf11073ProtocolTunnelClusterServerTickCallback(uint8_t endpoint); +/** @brief 11073 Protocol Tunnel Cluster Transfer A P D U + * + * + * + * @param apdu Ver.: always + */ +bool emberAf11073ProtocolTunnelClusterTransferAPDUCallback(uint8_t * apdu); + +/** @} END 11073 Protocol Tunnel Cluster Callbacks */ + +/** @name ISO 7816 Protocol Tunnel Cluster Callbacks */ +// @{ + +/** @brief ISO 7816 Protocol Tunnel Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientInitCallback(uint8_t endpoint); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIso7816ProtocolTunnelClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief ISO 7816 Protocol Tunnel Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterClientTickCallback(uint8_t endpoint); +/** @brief ISO 7816 Protocol Tunnel Cluster Extract Smart Card + * + * + * + */ +bool emberAfIso7816ProtocolTunnelClusterExtractSmartCardCallback(void); +/** @brief ISO 7816 Protocol Tunnel Cluster Insert Smart Card + * + * + * + */ +bool emberAfIso7816ProtocolTunnelClusterInsertSmartCardCallback(void); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerInitCallback(uint8_t endpoint); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfIso7816ProtocolTunnelClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief ISO 7816 Protocol Tunnel Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfIso7816ProtocolTunnelClusterServerTickCallback(uint8_t endpoint); +/** @brief ISO 7816 Protocol Tunnel Cluster Transfer Apdu + * + * + * + * @param apdu Ver.: always + */ +bool emberAfIso7816ProtocolTunnelClusterTransferApduCallback(uint8_t * apdu); + +/** @} END ISO 7816 Protocol Tunnel Cluster Callbacks */ + +/** @name Price Cluster Callbacks */ +// @{ + +/** @brief Price Cluster Cancel Tariff + * + * + * + * @param providerId Ver.: always + * @param issuerTariffId Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterCancelTariffCallback(uint32_t providerId, uint32_t issuerTariffId, uint8_t tariffType); +/** @brief Price Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPriceClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Price Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPriceClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Price Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPriceClusterClientInitCallback(uint8_t endpoint); +/** @brief Price Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPriceClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Price Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPriceClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Price Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPriceClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Price Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPriceClusterClientTickCallback(uint8_t endpoint); +/** @brief Price Cluster Cpp Event Response + * + * + * + * @param issuerEventId Ver.: always + * @param cppAuth Ver.: always + */ +bool emberAfPriceClusterCppEventResponseCallback(uint32_t issuerEventId, uint8_t cppAuth); +/** @brief Price Cluster Get Billing Period + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterGetBillingPeriodCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, uint8_t numberOfCommands, + uint8_t tariffType); +/** @brief Price Cluster Get Block Periods + * + * + * + * @param startTime Ver.: always + * @param numberOfEvents Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterGetBlockPeriodsCallback(uint32_t startTime, uint8_t numberOfEvents, uint8_t tariffType); +/** @brief Price Cluster Get Block Thresholds + * + * + * + * @param issuerTariffId Ver.: always + */ +bool emberAfPriceClusterGetBlockThresholdsCallback(uint32_t issuerTariffId); +/** @brief Price Cluster Get C O2 Value + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterGetCO2ValueCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, uint8_t numberOfCommands, + uint8_t tariffType); +/** @brief Price Cluster Get Calorific Value + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + */ +bool emberAfPriceClusterGetCalorificValueCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, uint8_t numberOfCommands); +/** @brief Price Cluster Get Consolidated Bill + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterGetConsolidatedBillCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, uint8_t numberOfCommands, + uint8_t tariffType); +/** @brief Price Cluster Get Conversion Factor + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + */ +bool emberAfPriceClusterGetConversionFactorCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, + uint8_t numberOfCommands); +/** @brief Price Cluster Get Credit Payment + * + * + * + * @param latestEndTime Ver.: always + * @param numberOfRecords Ver.: always + */ +bool emberAfPriceClusterGetCreditPaymentCallback(uint32_t latestEndTime, uint8_t numberOfRecords); +/** @brief Price Cluster Get Currency Conversion Command + * + * + * + */ +bool emberAfPriceClusterGetCurrencyConversionCommandCallback(void); +/** @brief Price Cluster Get Current Price + * + * + * + * @param commandOptions Ver.: always + */ +bool emberAfPriceClusterGetCurrentPriceCallback(uint8_t commandOptions); +/** @brief Price Cluster Get Price Matrix + * + * + * + * @param issuerTariffId Ver.: always + */ +bool emberAfPriceClusterGetPriceMatrixCallback(uint32_t issuerTariffId); +/** @brief Price Cluster Get Scheduled Prices + * + * + * + * @param startTime Ver.: always + * @param numberOfEvents Ver.: always + */ +bool emberAfPriceClusterGetScheduledPricesCallback(uint32_t startTime, uint8_t numberOfEvents); +/** @brief Price Cluster Get Tariff Cancellation + * + * + * + */ +bool emberAfPriceClusterGetTariffCancellationCallback(void); +/** @brief Price Cluster Get Tariff Information + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCommands Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterGetTariffInformationCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, + uint8_t numberOfCommands, uint8_t tariffType); +/** @brief Price Cluster Get Tier Labels + * + * + * + * @param issuerTariffId Ver.: always + */ +bool emberAfPriceClusterGetTierLabelsCallback(uint32_t issuerTariffId); +/** @brief Price Cluster Price Acknowledgement + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param priceAckTime Ver.: always + * @param control Ver.: always + */ +bool emberAfPriceClusterPriceAcknowledgementCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t priceAckTime, + uint8_t control); +/** @brief Price Cluster Publish Billing Period + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param billingPeriodStartTime Ver.: always + * @param billingPeriodDuration Ver.: always + * @param billingPeriodDurationType Ver.: always + * @param tariffType Ver.: always + */ +bool emberAfPriceClusterPublishBillingPeriodCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t billingPeriodStartTime, + uint32_t billingPeriodDuration, uint8_t billingPeriodDurationType, + uint8_t tariffType); +/** @brief Price Cluster Publish Block Period + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param blockPeriodStartTime Ver.: always + * @param blockPeriodDuration Ver.: always + * @param blockPeriodControl Ver.: always + * @param blockPeriodDurationType Ver.: since se-1.2a-07-5356-19 + * @param tariffType Ver.: since se-1.2a-07-5356-19 + * @param tariffResolutionPeriod Ver.: since se-1.2a-07-5356-19 + */ +bool emberAfPriceClusterPublishBlockPeriodCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t blockPeriodStartTime, + uint32_t blockPeriodDuration, uint8_t blockPeriodControl, + uint8_t blockPeriodDurationType, uint8_t tariffType, + uint8_t tariffResolutionPeriod); +/** @brief Price Cluster Publish Block Thresholds + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param issuerTariffId Ver.: always + * @param commandIndex Ver.: always + * @param numberOfCommands Ver.: always + * @param subPayloadControl Ver.: always + * @param payload Ver.: always + */ +bool emberAfPriceClusterPublishBlockThresholdsCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t startTime, + uint32_t issuerTariffId, uint8_t commandIndex, uint8_t numberOfCommands, + uint8_t subPayloadControl, uint8_t * payload); +/** @brief Price Cluster Publish C O2 Value + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param tariffType Ver.: always + * @param cO2Value Ver.: always + * @param cO2ValueUnit Ver.: always + * @param cO2ValueTrailingDigit Ver.: always + */ +bool emberAfPriceClusterPublishCO2ValueCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t startTime, uint8_t tariffType, + uint32_t cO2Value, uint8_t cO2ValueUnit, uint8_t cO2ValueTrailingDigit); +/** @brief Price Cluster Publish Calorific Value + * + * + * + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param calorificValue Ver.: always + * @param calorificValueUnit Ver.: always + * @param calorificValueTrailingDigit Ver.: always + */ +bool emberAfPriceClusterPublishCalorificValueCallback(uint32_t issuerEventId, uint32_t startTime, uint32_t calorificValue, + uint8_t calorificValueUnit, uint8_t calorificValueTrailingDigit); +/** @brief Price Cluster Publish Consolidated Bill + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param billingPeriodStartTime Ver.: always + * @param billingPeriodDuration Ver.: always + * @param billingPeriodDurationType Ver.: always + * @param tariffType Ver.: always + * @param consolidatedBill Ver.: always + * @param currency Ver.: always + * @param billTrailingDigit Ver.: always + */ +bool emberAfPriceClusterPublishConsolidatedBillCallback(uint32_t providerId, uint32_t issuerEventId, + uint32_t billingPeriodStartTime, uint32_t billingPeriodDuration, + uint8_t billingPeriodDurationType, uint8_t tariffType, + uint32_t consolidatedBill, uint16_t currency, uint8_t billTrailingDigit); +/** @brief Price Cluster Publish Conversion Factor + * + * + * + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param conversionFactor Ver.: always + * @param conversionFactorTrailingDigit Ver.: always + */ +bool emberAfPriceClusterPublishConversionFactorCallback(uint32_t issuerEventId, uint32_t startTime, uint32_t conversionFactor, + uint8_t conversionFactorTrailingDigit); +/** @brief Price Cluster Publish Cpp Event + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param durationInMinutes Ver.: always + * @param tariffType Ver.: always + * @param cppPriceTier Ver.: always + * @param cppAuth Ver.: always + */ +bool emberAfPriceClusterPublishCppEventCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t startTime, + uint16_t durationInMinutes, uint8_t tariffType, uint8_t cppPriceTier, + uint8_t cppAuth); +/** @brief Price Cluster Publish Credit Payment + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param creditPaymentDueDate Ver.: always + * @param creditPaymentOverDueAmount Ver.: always + * @param creditPaymentStatus Ver.: always + * @param creditPayment Ver.: always + * @param creditPaymentDate Ver.: always + * @param creditPaymentRef Ver.: always + */ +bool emberAfPriceClusterPublishCreditPaymentCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t creditPaymentDueDate, + uint32_t creditPaymentOverDueAmount, uint8_t creditPaymentStatus, + uint32_t creditPayment, uint32_t creditPaymentDate, + uint8_t * creditPaymentRef); +/** @brief Price Cluster Publish Currency Conversion + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param oldCurrency Ver.: always + * @param newCurrency Ver.: always + * @param conversionFactor Ver.: always + * @param conversionFactorTrailingDigit Ver.: always + * @param currencyChangeControlFlags Ver.: always + */ +bool emberAfPriceClusterPublishCurrencyConversionCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t startTime, + uint16_t oldCurrency, uint16_t newCurrency, uint32_t conversionFactor, + uint8_t conversionFactorTrailingDigit, + uint32_t currencyChangeControlFlags); +/** @brief Price Cluster Publish Price + * + * + * + * @param providerId Ver.: always + * @param rateLabel Ver.: always + * @param issuerEventId Ver.: always + * @param currentTime Ver.: always + * @param unitOfMeasure Ver.: always + * @param currency Ver.: always + * @param priceTrailingDigitAndPriceTier Ver.: always + * @param numberOfPriceTiersAndRegisterTier Ver.: always + * @param startTime Ver.: always + * @param durationInMinutes Ver.: always + * @param price Ver.: always + * @param priceRatio Ver.: always + * @param generationPrice Ver.: always + * @param generationPriceRatio Ver.: always + * @param alternateCostDelivered Ver.: since se-1.0-07-5356-15 + * @param alternateCostUnit Ver.: since se-1.0-07-5356-15 + * @param alternateCostTrailingDigit Ver.: since se-1.0-07-5356-15 + * @param numberOfBlockThresholds Ver.: since se-1.1-07-5356-16 + * @param priceControl Ver.: since se-1.1-07-5356-16 + * @param numberOfGenerationTiers Ver.: since se-1.2a-07-5356-19 + * @param generationTier Ver.: since se-1.2a-07-5356-19 + * @param extendedNumberOfPriceTiers Ver.: since se-1.2a-07-5356-19 + * @param extendedPriceTier Ver.: since se-1.2a-07-5356-19 + * @param extendedRegisterTier Ver.: since se-1.2a-07-5356-19 + */ +bool emberAfPriceClusterPublishPriceCallback( + uint32_t providerId, uint8_t * rateLabel, uint32_t issuerEventId, uint32_t currentTime, uint8_t unitOfMeasure, + uint16_t currency, uint8_t priceTrailingDigitAndPriceTier, uint8_t numberOfPriceTiersAndRegisterTier, uint32_t startTime, + uint16_t durationInMinutes, uint32_t price, uint8_t priceRatio, uint32_t generationPrice, uint8_t generationPriceRatio, + uint32_t alternateCostDelivered, uint8_t alternateCostUnit, uint8_t alternateCostTrailingDigit, uint8_t numberOfBlockThresholds, + uint8_t priceControl, uint8_t numberOfGenerationTiers, uint8_t generationTier, uint8_t extendedNumberOfPriceTiers, + uint8_t extendedPriceTier, uint8_t extendedRegisterTier); +/** @brief Price Cluster Publish Price Matrix + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param issuerTariffId Ver.: always + * @param commandIndex Ver.: always + * @param numberOfCommands Ver.: always + * @param subPayloadControl Ver.: always + * @param payload Ver.: always + */ +bool emberAfPriceClusterPublishPriceMatrixCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t startTime, + uint32_t issuerTariffId, uint8_t commandIndex, uint8_t numberOfCommands, + uint8_t subPayloadControl, uint8_t * payload); +/** @brief Price Cluster Publish Tariff Information + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerTariffId Ver.: always + * @param startTime Ver.: always + * @param tariffTypeChargingScheme Ver.: always + * @param tariffLabel Ver.: always + * @param numberOfPriceTiersInUse Ver.: always + * @param numberOfBlockThresholdsInUse Ver.: always + * @param unitOfMeasure Ver.: always + * @param currency Ver.: always + * @param priceTrailingDigit Ver.: always + * @param standingCharge Ver.: always + * @param tierBlockMode Ver.: always + * @param blockThresholdMultiplier Ver.: always + * @param blockThresholdDivisor Ver.: always + */ +bool emberAfPriceClusterPublishTariffInformationCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerTariffId, + uint32_t startTime, uint8_t tariffTypeChargingScheme, + uint8_t * tariffLabel, uint8_t numberOfPriceTiersInUse, + uint8_t numberOfBlockThresholdsInUse, uint8_t unitOfMeasure, + uint16_t currency, uint8_t priceTrailingDigit, uint32_t standingCharge, + uint8_t tierBlockMode, uint32_t blockThresholdMultiplier, + uint32_t blockThresholdDivisor); +/** @brief Price Cluster Publish Tier Labels + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerTariffId Ver.: always + * @param commandIndex Ver.: always + * @param numberOfCommands Ver.: always + * @param numberOfLabels Ver.: always + * @param tierLabelsPayload Ver.: always + */ +bool emberAfPriceClusterPublishTierLabelsCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerTariffId, + uint8_t commandIndex, uint8_t numberOfCommands, uint8_t numberOfLabels, + uint8_t * tierLabelsPayload); +/** @brief Price Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPriceClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Price Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPriceClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Price Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPriceClusterServerInitCallback(uint8_t endpoint); +/** @brief Price Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPriceClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Price Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPriceClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status); +/** @brief Price Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPriceClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Price Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPriceClusterServerTickCallback(uint8_t endpoint); + +/** @} END Price Cluster Callbacks */ + +/** @name Demand Response and Load Control Cluster Callbacks */ +// @{ + +/** @brief Demand Response and Load Control Cluster Cancel All Load Control Events + * + * + * + * @param cancelControl Ver.: always + */ +bool emberAfDemandResponseLoadControlClusterCancelAllLoadControlEventsCallback(uint8_t cancelControl); +/** @brief Demand Response and Load Control Cluster Cancel Load Control Event + * + * + * + * @param issuerEventId Ver.: always + * @param deviceClass Ver.: always + * @param utilityEnrollmentGroup Ver.: always + * @param cancelControl Ver.: always + * @param effectiveTime Ver.: always + */ +bool emberAfDemandResponseLoadControlClusterCancelLoadControlEventCallback(uint32_t issuerEventId, uint16_t deviceClass, + uint8_t utilityEnrollmentGroup, uint8_t cancelControl, + uint32_t effectiveTime); +/** @brief Demand Response and Load Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Demand Response and Load Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Demand Response and Load Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Demand Response and Load Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Demand Response and Load Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Demand Response and Load Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDemandResponseLoadControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Demand Response and Load Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDemandResponseLoadControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Demand Response and Load Control Cluster Get Scheduled Events + * + * + * + * @param startTime Ver.: always + * @param numberOfEvents Ver.: always + * @param issuerEventId Ver.: since se-1.2b-15-0131-02 + */ +bool emberAfDemandResponseLoadControlClusterGetScheduledEventsCallback(uint32_t startTime, uint8_t numberOfEvents, + uint32_t issuerEventId); +/** @brief Demand Response and Load Control Cluster Load Control Event + * + * + * + * @param issuerEventId Ver.: always + * @param deviceClass Ver.: always + * @param utilityEnrollmentGroup Ver.: always + * @param startTime Ver.: always + * @param durationInMinutes Ver.: always + * @param criticalityLevel Ver.: always + * @param coolingTemperatureOffset Ver.: always + * @param heatingTemperatureOffset Ver.: always + * @param coolingTemperatureSetPoint Ver.: always + * @param heatingTemperatureSetPoint Ver.: always + * @param averageLoadAdjustmentPercentage Ver.: always + * @param dutyCycle Ver.: always + * @param eventControl Ver.: always + */ +bool emberAfDemandResponseLoadControlClusterLoadControlEventCallback( + uint32_t issuerEventId, uint16_t deviceClass, uint8_t utilityEnrollmentGroup, uint32_t startTime, uint16_t durationInMinutes, + uint8_t criticalityLevel, uint8_t coolingTemperatureOffset, uint8_t heatingTemperatureOffset, + int16_t coolingTemperatureSetPoint, int16_t heatingTemperatureSetPoint, int8_t averageLoadAdjustmentPercentage, + uint8_t dutyCycle, uint8_t eventControl); +/** @brief Demand Response and Load Control Cluster Report Event Status + * + * + * + * @param issuerEventId Ver.: always + * @param eventStatus Ver.: always + * @param eventStatusTime Ver.: always + * @param criticalityLevelApplied Ver.: always + * @param coolingTemperatureSetPointApplied Ver.: always + * @param heatingTemperatureSetPointApplied Ver.: always + * @param averageLoadAdjustmentPercentageApplied Ver.: always + * @param dutyCycleApplied Ver.: always + * @param eventControl Ver.: always + * @param signatureType Ver.: always + * @param signature Ver.: always + */ +bool emberAfDemandResponseLoadControlClusterReportEventStatusCallback(uint32_t issuerEventId, uint8_t eventStatus, + uint32_t eventStatusTime, uint8_t criticalityLevelApplied, + uint16_t coolingTemperatureSetPointApplied, + uint16_t heatingTemperatureSetPointApplied, + int8_t averageLoadAdjustmentPercentageApplied, + uint8_t dutyCycleApplied, uint8_t eventControl, + uint8_t signatureType, uint8_t * signature); +/** @brief Demand Response and Load Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Demand Response and Load Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, + EmberAfStatus status); +/** @brief Demand Response and Load Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Demand Response and Load Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Demand Response and Load Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Demand Response and Load Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDemandResponseLoadControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Demand Response and Load Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDemandResponseLoadControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Demand Response and Load Control Cluster Callbacks */ + +/** @name Simple Metering Cluster Callbacks */ +// @{ + +/** @brief Simple Metering Cluster Change Supply + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param requestDateTime Ver.: always + * @param implementationDateTime Ver.: always + * @param proposedSupplyStatus Ver.: always + * @param supplyControlBits Ver.: always + */ +bool emberAfSimpleMeteringClusterChangeSupplyCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t requestDateTime, + uint32_t implementationDateTime, uint8_t proposedSupplyStatus, + uint8_t supplyControlBits); +/** @brief Simple Metering Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSimpleMeteringClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Simple Metering Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSimpleMeteringClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Simple Metering Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSimpleMeteringClusterClientInitCallback(uint8_t endpoint); +/** @brief Simple Metering Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSimpleMeteringClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Simple Metering Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSimpleMeteringClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Simple Metering Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSimpleMeteringClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Simple Metering Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSimpleMeteringClusterClientTickCallback(uint8_t endpoint); +/** @brief Simple Metering Cluster Configure Mirror + * + * + * + * @param issuerEventId Ver.: always + * @param reportingInterval Ver.: always + * @param mirrorNotificationReporting Ver.: always + * @param notificationScheme Ver.: always + */ +bool emberAfSimpleMeteringClusterConfigureMirrorCallback(uint32_t issuerEventId, uint32_t reportingInterval, + uint8_t mirrorNotificationReporting, uint8_t notificationScheme); +/** @brief Simple Metering Cluster Configure Notification Flags + * + * + * + * @param issuerEventId Ver.: always + * @param notificationScheme Ver.: always + * @param notificationFlagAttributeId Ver.: always + * @param clusterId Ver.: always + * @param manufacturerCode Ver.: always + * @param numberOfCommands Ver.: always + * @param commandIds Ver.: always + */ +bool emberAfSimpleMeteringClusterConfigureNotificationFlagsCallback(uint32_t issuerEventId, uint8_t notificationScheme, + uint16_t notificationFlagAttributeId, uint16_t clusterId, + uint16_t manufacturerCode, uint8_t numberOfCommands, + uint8_t * commandIds); +/** @brief Simple Metering Cluster Configure Notification Scheme + * + * + * + * @param issuerEventId Ver.: always + * @param notificationScheme Ver.: always + * @param notificationFlagOrder Ver.: always + */ +bool emberAfSimpleMeteringClusterConfigureNotificationSchemeCallback(uint32_t issuerEventId, uint8_t notificationScheme, + uint32_t notificationFlagOrder); +/** @brief Simple Metering Cluster Get Notified Message + * + * + * + * @param notificationScheme Ver.: always + * @param notificationFlagAttributeId Ver.: always + * @param notificationFlagsN Ver.: always + */ +bool emberAfSimpleMeteringClusterGetNotifiedMessageCallback(uint8_t notificationScheme, uint16_t notificationFlagAttributeId, + uint32_t notificationFlagsN); +/** @brief Simple Metering Cluster Get Profile + * + * + * + * @param intervalChannel Ver.: always + * @param endTime Ver.: always + * @param numberOfPeriods Ver.: always + */ +bool emberAfSimpleMeteringClusterGetProfileCallback(uint8_t intervalChannel, uint32_t endTime, uint8_t numberOfPeriods); +/** @brief Simple Metering Cluster Get Profile Response + * + * + * + * @param endTime Ver.: always + * @param status Ver.: always + * @param profileIntervalPeriod Ver.: always + * @param numberOfPeriodsDelivered Ver.: always + * @param intervals Ver.: always + */ +bool emberAfSimpleMeteringClusterGetProfileResponseCallback(uint32_t endTime, uint8_t status, uint8_t profileIntervalPeriod, + uint8_t numberOfPeriodsDelivered, uint8_t * intervals); +/** @brief Simple Metering Cluster Get Sampled Data + * + * + * + * @param sampleId Ver.: always + * @param earliestSampleTime Ver.: always + * @param sampleType Ver.: always + * @param numberOfSamples Ver.: always + */ +bool emberAfSimpleMeteringClusterGetSampledDataCallback(uint16_t sampleId, uint32_t earliestSampleTime, uint8_t sampleType, + uint16_t numberOfSamples); +/** @brief Simple Metering Cluster Get Sampled Data Response + * + * + * + * @param sampleId Ver.: always + * @param sampleStartTime Ver.: always + * @param sampleType Ver.: always + * @param sampleRequestInterval Ver.: always + * @param numberOfSamples Ver.: always + * @param samples Ver.: always + */ +bool emberAfSimpleMeteringClusterGetSampledDataResponseCallback(uint16_t sampleId, uint32_t sampleStartTime, uint8_t sampleType, + uint16_t sampleRequestInterval, uint16_t numberOfSamples, + uint8_t * samples); +/** @brief Simple Metering Cluster Get Snapshot + * + * + * + * @param earliestStartTime Ver.: always + * @param latestEndTime Ver.: always + * @param snapshotOffset Ver.: always + * @param snapshotCause Ver.: always + */ +bool emberAfSimpleMeteringClusterGetSnapshotCallback(uint32_t earliestStartTime, uint32_t latestEndTime, uint8_t snapshotOffset, + uint32_t snapshotCause); +/** @brief Simple Metering Cluster Local Change Supply + * + * + * + * @param proposedSupplyStatus Ver.: always + */ +bool emberAfSimpleMeteringClusterLocalChangeSupplyCallback(uint8_t proposedSupplyStatus); +/** @brief Simple Metering Cluster Mirror Removed + * + * + * + * @param endpointId Ver.: always + */ +bool emberAfSimpleMeteringClusterMirrorRemovedCallback(uint16_t endpointId); +/** @brief Simple Metering Cluster Mirror Report Attribute Response + * + * + * + * @param notificationScheme Ver.: always + * @param notificationFlags Ver.: always + */ +bool emberAfSimpleMeteringClusterMirrorReportAttributeResponseCallback(uint8_t notificationScheme, uint8_t * notificationFlags); +/** @brief Simple Metering Cluster Publish Snapshot + * + * + * + * @param snapshotId Ver.: always + * @param snapshotTime Ver.: always + * @param totalSnapshotsFound Ver.: always + * @param commandIndex Ver.: always + * @param totalCommands Ver.: always + * @param snapshotCause Ver.: always + * @param snapshotPayloadType Ver.: always + * @param snapshotPayload Ver.: always + */ +bool emberAfSimpleMeteringClusterPublishSnapshotCallback(uint32_t snapshotId, uint32_t snapshotTime, uint8_t totalSnapshotsFound, + uint8_t commandIndex, uint8_t totalCommands, uint32_t snapshotCause, + uint8_t snapshotPayloadType, uint8_t * snapshotPayload); +/** @brief Simple Metering Cluster Remove Mirror + * + * + * + */ +bool emberAfSimpleMeteringClusterRemoveMirrorCallback(void); +/** @brief Simple Metering Cluster Request Fast Poll Mode + * + * + * + * @param fastPollUpdatePeriod Ver.: always + * @param duration Ver.: always + */ +bool emberAfSimpleMeteringClusterRequestFastPollModeCallback(uint8_t fastPollUpdatePeriod, uint8_t duration); +/** @brief Simple Metering Cluster Request Fast Poll Mode Response + * + * + * + * @param appliedUpdatePeriod Ver.: always + * @param fastPollModeEndtime Ver.: always + */ +bool emberAfSimpleMeteringClusterRequestFastPollModeResponseCallback(uint8_t appliedUpdatePeriod, uint32_t fastPollModeEndtime); +/** @brief Simple Metering Cluster Request Mirror + * + * + * + */ +bool emberAfSimpleMeteringClusterRequestMirrorCallback(void); +/** @brief Simple Metering Cluster Request Mirror Response + * + * + * + * @param endpointId Ver.: always + */ +bool emberAfSimpleMeteringClusterRequestMirrorResponseCallback(uint16_t endpointId); +/** @brief Simple Metering Cluster Reset Load Limit Counter + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + */ +bool emberAfSimpleMeteringClusterResetLoadLimitCounterCallback(uint32_t providerId, uint32_t issuerEventId); +/** @brief Simple Metering Cluster Schedule Snapshot + * + * + * + * @param issuerEventId Ver.: always + * @param commandIndex Ver.: always + * @param commandCount Ver.: always + * @param snapshotSchedulePayload Ver.: always + */ +bool emberAfSimpleMeteringClusterScheduleSnapshotCallback(uint32_t issuerEventId, uint8_t commandIndex, uint8_t commandCount, + uint8_t * snapshotSchedulePayload); +/** @brief Simple Metering Cluster Schedule Snapshot Response + * + * + * + * @param issuerEventId Ver.: always + * @param snapshotResponsePayload Ver.: always + */ +bool emberAfSimpleMeteringClusterScheduleSnapshotResponseCallback(uint32_t issuerEventId, uint8_t * snapshotResponsePayload); +/** @brief Simple Metering Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSimpleMeteringClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Simple Metering Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSimpleMeteringClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Simple Metering Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSimpleMeteringClusterServerInitCallback(uint8_t endpoint); +/** @brief Simple Metering Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSimpleMeteringClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Simple Metering Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSimpleMeteringClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Simple Metering Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSimpleMeteringClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Simple Metering Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSimpleMeteringClusterServerTickCallback(uint8_t endpoint); +/** @brief Simple Metering Cluster Set Supply Status + * + * + * + * @param issuerEventId Ver.: always + * @param supplyTamperState Ver.: always + * @param supplyDepletionState Ver.: always + * @param supplyUncontrolledFlowState Ver.: always + * @param loadLimitSupplyState Ver.: always + */ +bool emberAfSimpleMeteringClusterSetSupplyStatusCallback(uint32_t issuerEventId, uint8_t supplyTamperState, + uint8_t supplyDepletionState, uint8_t supplyUncontrolledFlowState, + uint8_t loadLimitSupplyState); +/** @brief Simple Metering Cluster Set Uncontrolled Flow Threshold + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param uncontrolledFlowThreshold Ver.: always + * @param unitOfMeasure Ver.: always + * @param multiplier Ver.: always + * @param divisor Ver.: always + * @param stabilisationPeriod Ver.: always + * @param measurementPeriod Ver.: always + */ +bool emberAfSimpleMeteringClusterSetUncontrolledFlowThresholdCallback(uint32_t providerId, uint32_t issuerEventId, + uint16_t uncontrolledFlowThreshold, uint8_t unitOfMeasure, + uint16_t multiplier, uint16_t divisor, + uint8_t stabilisationPeriod, uint16_t measurementPeriod); +/** @brief Simple Metering Cluster Start Sampling + * + * + * + * @param issuerEventId Ver.: always + * @param startSamplingTime Ver.: always + * @param sampleType Ver.: always + * @param sampleRequestInterval Ver.: always + * @param maxNumberOfSamples Ver.: always + */ +bool emberAfSimpleMeteringClusterStartSamplingCallback(uint32_t issuerEventId, uint32_t startSamplingTime, uint8_t sampleType, + uint16_t sampleRequestInterval, uint16_t maxNumberOfSamples); +/** @brief Simple Metering Cluster Start Sampling Response + * + * + * + * @param sampleId Ver.: always + */ +bool emberAfSimpleMeteringClusterStartSamplingResponseCallback(uint16_t sampleId); +/** @brief Simple Metering Cluster Supply Status Response + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param implementationDateTime Ver.: always + * @param supplyStatus Ver.: always + */ +bool emberAfSimpleMeteringClusterSupplyStatusResponseCallback(uint32_t providerId, uint32_t issuerEventId, + uint32_t implementationDateTime, uint8_t supplyStatus); +/** @brief Simple Metering Cluster Take Snapshot + * + * + * + * @param snapshotCause Ver.: always + */ +bool emberAfSimpleMeteringClusterTakeSnapshotCallback(uint32_t snapshotCause); +/** @brief Simple Metering Cluster Take Snapshot Response + * + * + * + * @param snapshotId Ver.: always + * @param snapshotConfirmation Ver.: always + */ +bool emberAfSimpleMeteringClusterTakeSnapshotResponseCallback(uint32_t snapshotId, uint8_t snapshotConfirmation); + +/** @} END Simple Metering Cluster Callbacks */ + +/** @name Messaging Cluster Callbacks */ +// @{ + +/** @brief Messaging Cluster Cancel All Messages + * + * + * + * @param implementationDateTime Ver.: always + */ +bool emberAfMessagingClusterCancelAllMessagesCallback(uint32_t implementationDateTime); +/** @brief Messaging Cluster Cancel Message + * + * + * + * @param messageId Ver.: always + * @param messageControl Ver.: always + */ +bool emberAfMessagingClusterCancelMessageCallback(uint32_t messageId, uint8_t messageControl); +/** @brief Messaging Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMessagingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Messaging Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMessagingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Messaging Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMessagingClusterClientInitCallback(uint8_t endpoint); +/** @brief Messaging Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMessagingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Messaging Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMessagingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Messaging Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMessagingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Messaging Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMessagingClusterClientTickCallback(uint8_t endpoint); +/** @brief Messaging Cluster Display Message + * + * + * + * @param messageId Ver.: always + * @param messageControl Ver.: always + * @param startTime Ver.: always + * @param durationInMinutes Ver.: always + * @param message Ver.: always + * @param optionalExtendedMessageControl Ver.: since se-1.2a-07-5356-19 + */ +bool emberAfMessagingClusterDisplayMessageCallback(uint32_t messageId, uint8_t messageControl, uint32_t startTime, + uint16_t durationInMinutes, uint8_t * message, + uint8_t optionalExtendedMessageControl); +/** @brief Messaging Cluster Display Protected Message + * + * + * + * @param messageId Ver.: always + * @param messageControl Ver.: always + * @param startTime Ver.: always + * @param durationInMinutes Ver.: always + * @param message Ver.: always + * @param optionalExtendedMessageControl Ver.: always + */ +bool emberAfMessagingClusterDisplayProtectedMessageCallback(uint32_t messageId, uint8_t messageControl, uint32_t startTime, + uint16_t durationInMinutes, uint8_t * message, + uint8_t optionalExtendedMessageControl); +/** @brief Messaging Cluster Get Last Message + * + * + * + */ +bool emberAfMessagingClusterGetLastMessageCallback(void); +/** @brief Messaging Cluster Get Message Cancellation + * + * + * + * @param earliestImplementationTime Ver.: always + */ +bool emberAfMessagingClusterGetMessageCancellationCallback(uint32_t earliestImplementationTime); +/** @brief Messaging Cluster Message Confirmation + * + * + * + * @param messageId Ver.: always + * @param confirmationTime Ver.: always + * @param messageConfirmationControl Ver.: since se-1.2a-07-5356-19 + * @param messageResponse Ver.: since se-1.2a-07-5356-19 + */ +bool emberAfMessagingClusterMessageConfirmationCallback(uint32_t messageId, uint32_t confirmationTime, + uint8_t messageConfirmationControl, uint8_t * messageResponse); +/** @brief Messaging Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMessagingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Messaging Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMessagingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Messaging Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMessagingClusterServerInitCallback(uint8_t endpoint); +/** @brief Messaging Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMessagingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Messaging Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMessagingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Messaging Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMessagingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Messaging Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMessagingClusterServerTickCallback(uint8_t endpoint); + +/** @} END Messaging Cluster Callbacks */ + +/** @name Tunneling Cluster Callbacks */ +// @{ + +/** @brief Tunneling Cluster Ack Transfer Data Client To Server + * + * + * + * @param tunnelId Ver.: always + * @param numberOfBytesLeft Ver.: always + */ +bool emberAfTunnelingClusterAckTransferDataClientToServerCallback(uint16_t tunnelId, uint16_t numberOfBytesLeft); +/** @brief Tunneling Cluster Ack Transfer Data Server To Client + * + * + * + * @param tunnelId Ver.: always + * @param numberOfBytesLeft Ver.: always + */ +bool emberAfTunnelingClusterAckTransferDataServerToClientCallback(uint16_t tunnelId, uint16_t numberOfBytesLeft); +/** @brief Tunneling Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTunnelingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Tunneling Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTunnelingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Tunneling Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTunnelingClusterClientInitCallback(uint8_t endpoint); +/** @brief Tunneling Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTunnelingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Tunneling Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTunnelingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Tunneling Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTunnelingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Tunneling Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTunnelingClusterClientTickCallback(uint8_t endpoint); +/** @brief Tunneling Cluster Close Tunnel + * + * + * + * @param tunnelId Ver.: always + */ +bool emberAfTunnelingClusterCloseTunnelCallback(uint16_t tunnelId); +/** @brief Tunneling Cluster Get Supported Tunnel Protocols + * + * + * + * @param protocolOffset Ver.: always + */ +bool emberAfTunnelingClusterGetSupportedTunnelProtocolsCallback(uint8_t protocolOffset); +/** @brief Tunneling Cluster Ready Data Client To Server + * + * + * + * @param tunnelId Ver.: always + * @param numberOfOctetsLeft Ver.: always + */ +bool emberAfTunnelingClusterReadyDataClientToServerCallback(uint16_t tunnelId, uint16_t numberOfOctetsLeft); +/** @brief Tunneling Cluster Ready Data Server To Client + * + * + * + * @param tunnelId Ver.: always + * @param numberOfOctetsLeft Ver.: always + */ +bool emberAfTunnelingClusterReadyDataServerToClientCallback(uint16_t tunnelId, uint16_t numberOfOctetsLeft); +/** @brief Tunneling Cluster Request Tunnel + * + * + * + * @param protocolId Ver.: always + * @param manufacturerCode Ver.: always + * @param flowControlSupport Ver.: always + * @param maximumIncomingTransferSize Ver.: since se-1.1a-07-5356-17 + */ +bool emberAfTunnelingClusterRequestTunnelCallback(uint8_t protocolId, uint16_t manufacturerCode, uint8_t flowControlSupport, + uint16_t maximumIncomingTransferSize); +/** @brief Tunneling Cluster Request Tunnel Response + * + * + * + * @param tunnelId Ver.: always + * @param tunnelStatus Ver.: always + * @param maximumIncomingTransferSize Ver.: since se-1.1a-07-5356-17 + */ +bool emberAfTunnelingClusterRequestTunnelResponseCallback(uint16_t tunnelId, uint8_t tunnelStatus, + uint16_t maximumIncomingTransferSize); +/** @brief Tunneling Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfTunnelingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Tunneling Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfTunnelingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Tunneling Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfTunnelingClusterServerInitCallback(uint8_t endpoint); +/** @brief Tunneling Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfTunnelingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Tunneling Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfTunnelingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Tunneling Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfTunnelingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Tunneling Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfTunnelingClusterServerTickCallback(uint8_t endpoint); +/** @brief Tunneling Cluster Supported Tunnel Protocols Response + * + * + * + * @param protocolListComplete Ver.: always + * @param protocolCount Ver.: always + * @param protocolList Ver.: always + */ +bool emberAfTunnelingClusterSupportedTunnelProtocolsResponseCallback(uint8_t protocolListComplete, uint8_t protocolCount, + uint8_t * protocolList); +/** @brief Tunneling Cluster Transfer Data Client To Server + * + * + * + * @param tunnelId Ver.: always + * @param data Ver.: always + */ +bool emberAfTunnelingClusterTransferDataClientToServerCallback(uint16_t tunnelId, uint8_t * data); +/** @brief Tunneling Cluster Transfer Data Error Client To Server + * + * + * + * @param tunnelId Ver.: always + * @param transferDataStatus Ver.: always + */ +bool emberAfTunnelingClusterTransferDataErrorClientToServerCallback(uint16_t tunnelId, uint8_t transferDataStatus); +/** @brief Tunneling Cluster Transfer Data Error Server To Client + * + * + * + * @param tunnelId Ver.: always + * @param transferDataStatus Ver.: always + */ +bool emberAfTunnelingClusterTransferDataErrorServerToClientCallback(uint16_t tunnelId, uint8_t transferDataStatus); +/** @brief Tunneling Cluster Transfer Data Server To Client + * + * + * + * @param tunnelId Ver.: always + * @param data Ver.: always + */ +bool emberAfTunnelingClusterTransferDataServerToClientCallback(uint16_t tunnelId, uint8_t * data); +/** @brief Tunneling Cluster Tunnel Closure Notification + * + * + * + * @param tunnelId Ver.: always + */ +bool emberAfTunnelingClusterTunnelClosureNotificationCallback(uint16_t tunnelId); + +/** @} END Tunneling Cluster Callbacks */ + +/** @name Prepayment Cluster Callbacks */ +// @{ + +/** @brief Prepayment Cluster Change Debt + * + * + * + * @param issuerEventId Ver.: always + * @param debtLabel Ver.: always + * @param debtAmount Ver.: always + * @param debtRecoveryMethod Ver.: always + * @param debtAmountType Ver.: always + * @param debtRecoveryStartTime Ver.: always + * @param debtRecoveryCollectionTime Ver.: always + * @param debtRecoveryFrequency Ver.: always + * @param debtRecoveryAmount Ver.: always + * @param debtRecoveryBalancePercentage Ver.: always + */ +bool emberAfPrepaymentClusterChangeDebtCallback(uint32_t issuerEventId, uint8_t * debtLabel, uint32_t debtAmount, + uint8_t debtRecoveryMethod, uint8_t debtAmountType, uint32_t debtRecoveryStartTime, + uint16_t debtRecoveryCollectionTime, uint8_t debtRecoveryFrequency, + uint32_t debtRecoveryAmount, uint16_t debtRecoveryBalancePercentage); +/** @brief Prepayment Cluster Change Payment Mode + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param implementationDateTime Ver.: always + * @param proposedPaymentControlConfiguration Ver.: always + * @param cutOffValue Ver.: always + */ +bool emberAfPrepaymentClusterChangePaymentModeCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t implementationDateTime, + uint16_t proposedPaymentControlConfiguration, uint32_t cutOffValue); +/** @brief Prepayment Cluster Change Payment Mode Response + * + * + * + * @param friendlyCredit Ver.: always + * @param friendlyCreditCalendarId Ver.: always + * @param emergencyCreditLimit Ver.: always + * @param emergencyCreditThreshold Ver.: always + */ +bool emberAfPrepaymentClusterChangePaymentModeResponseCallback(uint8_t friendlyCredit, uint32_t friendlyCreditCalendarId, + uint32_t emergencyCreditLimit, uint32_t emergencyCreditThreshold); +/** @brief Prepayment Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPrepaymentClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Prepayment Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPrepaymentClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Prepayment Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPrepaymentClusterClientInitCallback(uint8_t endpoint); +/** @brief Prepayment Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPrepaymentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Prepayment Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPrepaymentClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Prepayment Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPrepaymentClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Prepayment Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPrepaymentClusterClientTickCallback(uint8_t endpoint); +/** @brief Prepayment Cluster Consumer Top Up + * + * + * + * @param originatingDevice Ver.: always + * @param topUpCode Ver.: always + */ +bool emberAfPrepaymentClusterConsumerTopUpCallback(uint8_t originatingDevice, uint8_t * topUpCode); +/** @brief Prepayment Cluster Consumer Top Up Response + * + * + * + * @param resultType Ver.: always + * @param topUpValue Ver.: always + * @param sourceOfTopUp Ver.: always + * @param creditRemaining Ver.: always + */ +bool emberAfPrepaymentClusterConsumerTopUpResponseCallback(uint8_t resultType, uint32_t topUpValue, uint8_t sourceOfTopUp, + uint32_t creditRemaining); +/** @brief Prepayment Cluster Credit Adjustment + * + * + * + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param creditAdjustmentType Ver.: always + * @param creditAdjustmentValue Ver.: always + */ +bool emberAfPrepaymentClusterCreditAdjustmentCallback(uint32_t issuerEventId, uint32_t startTime, uint8_t creditAdjustmentType, + uint32_t creditAdjustmentValue); +/** @brief Prepayment Cluster Emergency Credit Setup + * + * + * + * @param issuerEventId Ver.: always + * @param startTime Ver.: always + * @param emergencyCreditLimit Ver.: always + * @param emergencyCreditThreshold Ver.: always + */ +bool emberAfPrepaymentClusterEmergencyCreditSetupCallback(uint32_t issuerEventId, uint32_t startTime, uint32_t emergencyCreditLimit, + uint32_t emergencyCreditThreshold); +/** @brief Prepayment Cluster Get Debt Repayment Log + * + * + * + * @param latestEndTime Ver.: always + * @param numberOfDebts Ver.: always + * @param debtType Ver.: always + */ +bool emberAfPrepaymentClusterGetDebtRepaymentLogCallback(uint32_t latestEndTime, uint8_t numberOfDebts, uint8_t debtType); +/** @brief Prepayment Cluster Get Prepay Snapshot + * + * + * + * @param earliestStartTime Ver.: always + * @param latestEndTime Ver.: always + * @param snapshotOffset Ver.: always + * @param snapshotCause Ver.: always + */ +bool emberAfPrepaymentClusterGetPrepaySnapshotCallback(uint32_t earliestStartTime, uint32_t latestEndTime, uint8_t snapshotOffset, + uint32_t snapshotCause); +/** @brief Prepayment Cluster Get Top Up Log + * + * + * + * @param latestEndTime Ver.: always + * @param numberOfRecords Ver.: always + */ +bool emberAfPrepaymentClusterGetTopUpLogCallback(uint32_t latestEndTime, uint8_t numberOfRecords); +/** @brief Prepayment Cluster Publish Debt Log + * + * + * + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param debtPayload Ver.: always + */ +bool emberAfPrepaymentClusterPublishDebtLogCallback(uint8_t commandIndex, uint8_t totalNumberOfCommands, uint8_t * debtPayload); +/** @brief Prepayment Cluster Publish Prepay Snapshot + * + * + * + * @param snapshotId Ver.: always + * @param snapshotTime Ver.: always + * @param totalSnapshotsFound Ver.: always + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param snapshotCause Ver.: always + * @param snapshotPayloadType Ver.: always + * @param snapshotPayload Ver.: always + */ +bool emberAfPrepaymentClusterPublishPrepaySnapshotCallback(uint32_t snapshotId, uint32_t snapshotTime, uint8_t totalSnapshotsFound, + uint8_t commandIndex, uint8_t totalNumberOfCommands, + uint32_t snapshotCause, uint8_t snapshotPayloadType, + uint8_t * snapshotPayload); +/** @brief Prepayment Cluster Publish Top Up Log + * + * + * + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param topUpPayload Ver.: always + */ +bool emberAfPrepaymentClusterPublishTopUpLogCallback(uint8_t commandIndex, uint8_t totalNumberOfCommands, uint8_t * topUpPayload); +/** @brief Prepayment Cluster Select Available Emergency Credit + * + * + * + * @param commandIssueDateTime Ver.: always + * @param originatingDevice Ver.: always + */ +bool emberAfPrepaymentClusterSelectAvailableEmergencyCreditCallback(uint32_t commandIssueDateTime, uint8_t originatingDevice); +/** @brief Prepayment Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPrepaymentClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Prepayment Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPrepaymentClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Prepayment Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPrepaymentClusterServerInitCallback(uint8_t endpoint); +/** @brief Prepayment Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPrepaymentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Prepayment Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPrepaymentClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Prepayment Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPrepaymentClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Prepayment Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPrepaymentClusterServerTickCallback(uint8_t endpoint); +/** @brief Prepayment Cluster Set Low Credit Warning Level + * + * + * + * @param lowCreditWarningLevel Ver.: always + */ +bool emberAfPrepaymentClusterSetLowCreditWarningLevelCallback(uint32_t lowCreditWarningLevel); +/** @brief Prepayment Cluster Set Maximum Credit Limit + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param implementationDateTime Ver.: always + * @param maximumCreditLevel Ver.: always + * @param maximumCreditPerTopUp Ver.: always + */ +bool emberAfPrepaymentClusterSetMaximumCreditLimitCallback(uint32_t providerId, uint32_t issuerEventId, + uint32_t implementationDateTime, uint32_t maximumCreditLevel, + uint32_t maximumCreditPerTopUp); +/** @brief Prepayment Cluster Set Overall Debt Cap + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param implementationDateTime Ver.: always + * @param overallDebtCap Ver.: always + */ +bool emberAfPrepaymentClusterSetOverallDebtCapCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t implementationDateTime, + uint32_t overallDebtCap); + +/** @} END Prepayment Cluster Callbacks */ + +/** @name Energy Management Cluster Callbacks */ +// @{ + +/** @brief Energy Management Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEnergyManagementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Energy Management Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEnergyManagementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Energy Management Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEnergyManagementClusterClientInitCallback(uint8_t endpoint); +/** @brief Energy Management Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEnergyManagementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Energy Management Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEnergyManagementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Energy Management Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEnergyManagementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Energy Management Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEnergyManagementClusterClientTickCallback(uint8_t endpoint); +/** @brief Energy Management Cluster Manage Event + * + * + * + * @param issuerEventId Ver.: always + * @param deviceClass Ver.: always + * @param utilityEnrollmentGroup Ver.: always + * @param actionRequired Ver.: always + */ +bool emberAfEnergyManagementClusterManageEventCallback(uint32_t issuerEventId, uint16_t deviceClass, uint8_t utilityEnrollmentGroup, + uint8_t actionRequired); +/** @brief Energy Management Cluster Report Event Status + * + * + * + * @param issuerEventId Ver.: always + * @param eventStatus Ver.: always + * @param eventStatusTime Ver.: always + * @param criticalityLevelApplied Ver.: always + * @param coolingTemperatureSetPointApplied Ver.: always + * @param heatingTemperatureSetPointApplied Ver.: always + * @param averageLoadAdjustmentPercentageApplied Ver.: always + * @param dutyCycleApplied Ver.: always + * @param eventControl Ver.: always + */ +bool emberAfEnergyManagementClusterReportEventStatusCallback(uint32_t issuerEventId, uint8_t eventStatus, uint32_t eventStatusTime, + uint8_t criticalityLevelApplied, + uint16_t coolingTemperatureSetPointApplied, + uint16_t heatingTemperatureSetPointApplied, + int8_t averageLoadAdjustmentPercentageApplied, + uint8_t dutyCycleApplied, uint8_t eventControl); +/** @brief Energy Management Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEnergyManagementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Energy Management Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEnergyManagementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Energy Management Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEnergyManagementClusterServerInitCallback(uint8_t endpoint); +/** @brief Energy Management Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEnergyManagementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Energy Management Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEnergyManagementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Energy Management Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEnergyManagementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Energy Management Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEnergyManagementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Energy Management Cluster Callbacks */ + +/** @name Calendar Cluster Callbacks */ +// @{ + +/** @brief Calendar Cluster Cancel Calendar + * + * + * + * @param providerId Ver.: always + * @param issuerCalendarId Ver.: always + * @param calendarType Ver.: always + */ +bool emberAfCalendarClusterCancelCalendarCallback(uint32_t providerId, uint32_t issuerCalendarId, uint8_t calendarType); +/** @brief Calendar Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCalendarClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Calendar Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCalendarClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Calendar Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCalendarClusterClientInitCallback(uint8_t endpoint); +/** @brief Calendar Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCalendarClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Calendar Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCalendarClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Calendar Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCalendarClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Calendar Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCalendarClusterClientTickCallback(uint8_t endpoint); +/** @brief Calendar Cluster Get Calendar + * + * + * + * @param earliestStartTime Ver.: always + * @param minIssuerEventId Ver.: always + * @param numberOfCalendars Ver.: always + * @param calendarType Ver.: always + * @param providerId Ver.: always + */ +bool emberAfCalendarClusterGetCalendarCallback(uint32_t earliestStartTime, uint32_t minIssuerEventId, uint8_t numberOfCalendars, + uint8_t calendarType, uint32_t providerId); +/** @brief Calendar Cluster Get Calendar Cancellation + * + * + * + */ +bool emberAfCalendarClusterGetCalendarCancellationCallback(void); +/** @brief Calendar Cluster Get Day Profiles + * + * + * + * @param providerId Ver.: always + * @param issuerCalendarId Ver.: always + * @param startDayId Ver.: always + * @param numberOfDays Ver.: always + */ +bool emberAfCalendarClusterGetDayProfilesCallback(uint32_t providerId, uint32_t issuerCalendarId, uint8_t startDayId, + uint8_t numberOfDays); +/** @brief Calendar Cluster Get Seasons + * + * + * + * @param providerId Ver.: always + * @param issuerCalendarId Ver.: always + */ +bool emberAfCalendarClusterGetSeasonsCallback(uint32_t providerId, uint32_t issuerCalendarId); +/** @brief Calendar Cluster Get Special Days + * + * + * + * @param startTime Ver.: always + * @param numberOfEvents Ver.: always + * @param calendarType Ver.: always + * @param providerId Ver.: always + * @param issuerCalendarId Ver.: always + */ +bool emberAfCalendarClusterGetSpecialDaysCallback(uint32_t startTime, uint8_t numberOfEvents, uint8_t calendarType, + uint32_t providerId, uint32_t issuerCalendarId); +/** @brief Calendar Cluster Get Week Profiles + * + * + * + * @param providerId Ver.: always + * @param issuerCalendarId Ver.: always + * @param startWeekId Ver.: always + * @param numberOfWeeks Ver.: always + */ +bool emberAfCalendarClusterGetWeekProfilesCallback(uint32_t providerId, uint32_t issuerCalendarId, uint8_t startWeekId, + uint8_t numberOfWeeks); +/** @brief Calendar Cluster Publish Calendar + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerCalendarId Ver.: always + * @param startTime Ver.: always + * @param calendarType Ver.: always + * @param calendarTimeReference Ver.: always + * @param calendarName Ver.: always + * @param numberOfSeasons Ver.: always + * @param numberOfWeekProfiles Ver.: always + * @param numberOfDayProfiles Ver.: always + */ +bool emberAfCalendarClusterPublishCalendarCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerCalendarId, + uint32_t startTime, uint8_t calendarType, uint8_t calendarTimeReference, + uint8_t * calendarName, uint8_t numberOfSeasons, uint8_t numberOfWeekProfiles, + uint8_t numberOfDayProfiles); +/** @brief Calendar Cluster Publish Day Profile + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerCalendarId Ver.: always + * @param dayId Ver.: always + * @param totalNumberOfScheduleEntries Ver.: always + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param calendarType Ver.: always + * @param dayScheduleEntries Ver.: always + */ +bool emberAfCalendarClusterPublishDayProfileCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerCalendarId, + uint8_t dayId, uint8_t totalNumberOfScheduleEntries, uint8_t commandIndex, + uint8_t totalNumberOfCommands, uint8_t calendarType, + uint8_t * dayScheduleEntries); +/** @brief Calendar Cluster Publish Seasons + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerCalendarId Ver.: always + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param seasonEntries Ver.: always + */ +bool emberAfCalendarClusterPublishSeasonsCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerCalendarId, + uint8_t commandIndex, uint8_t totalNumberOfCommands, uint8_t * seasonEntries); +/** @brief Calendar Cluster Publish Special Days + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerCalendarId Ver.: always + * @param startTime Ver.: always + * @param calendarType Ver.: always + * @param totalNumberOfSpecialDays Ver.: always + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param specialDayEntries Ver.: always + */ +bool emberAfCalendarClusterPublishSpecialDaysCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerCalendarId, + uint32_t startTime, uint8_t calendarType, uint8_t totalNumberOfSpecialDays, + uint8_t commandIndex, uint8_t totalNumberOfCommands, + uint8_t * specialDayEntries); +/** @brief Calendar Cluster Publish Week Profile + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param issuerCalendarId Ver.: always + * @param weekId Ver.: always + * @param dayIdRefMonday Ver.: always + * @param dayIdRefTuesday Ver.: always + * @param dayIdRefWednesday Ver.: always + * @param dayIdRefThursday Ver.: always + * @param dayIdRefFriday Ver.: always + * @param dayIdRefSaturday Ver.: always + * @param dayIdRefSunday Ver.: always + */ +bool emberAfCalendarClusterPublishWeekProfileCallback(uint32_t providerId, uint32_t issuerEventId, uint32_t issuerCalendarId, + uint8_t weekId, uint8_t dayIdRefMonday, uint8_t dayIdRefTuesday, + uint8_t dayIdRefWednesday, uint8_t dayIdRefThursday, uint8_t dayIdRefFriday, + uint8_t dayIdRefSaturday, uint8_t dayIdRefSunday); +/** @brief Calendar Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfCalendarClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Calendar Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfCalendarClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Calendar Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfCalendarClusterServerInitCallback(uint8_t endpoint); +/** @brief Calendar Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfCalendarClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Calendar Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfCalendarClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Calendar Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfCalendarClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Calendar Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfCalendarClusterServerTickCallback(uint8_t endpoint); + +/** @} END Calendar Cluster Callbacks */ + +/** @name Device Management Cluster Callbacks */ +// @{ + +/** @brief Device Management Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDeviceManagementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Device Management Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDeviceManagementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Device Management Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDeviceManagementClusterClientInitCallback(uint8_t endpoint); +/** @brief Device Management Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDeviceManagementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Device Management Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDeviceManagementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Device Management Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDeviceManagementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Device Management Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDeviceManagementClusterClientTickCallback(uint8_t endpoint); +/** @brief Device Management Cluster Get C I N + * + * + * + */ +bool emberAfDeviceManagementClusterGetCINCallback(void); +/** @brief Device Management Cluster Get Change Of Supplier + * + * + * + */ +bool emberAfDeviceManagementClusterGetChangeOfSupplierCallback(void); +/** @brief Device Management Cluster Get Change Of Tenancy + * + * + * + */ +bool emberAfDeviceManagementClusterGetChangeOfTenancyCallback(void); +/** @brief Device Management Cluster Get Event Configuration + * + * + * + * @param eventId Ver.: always + */ +bool emberAfDeviceManagementClusterGetEventConfigurationCallback(uint16_t eventId); +/** @brief Device Management Cluster Get Site Id + * + * + * + */ +bool emberAfDeviceManagementClusterGetSiteIdCallback(void); +/** @brief Device Management Cluster Publish Change Of Supplier + * + * + * + * @param currentProviderId Ver.: always + * @param issuerEventId Ver.: always + * @param tariffType Ver.: always + * @param proposedProviderId Ver.: always + * @param providerChangeImplementationTime Ver.: always + * @param providerChangeControl Ver.: always + * @param proposedProviderName Ver.: always + * @param proposedProviderContactDetails Ver.: always + */ +bool emberAfDeviceManagementClusterPublishChangeOfSupplierCallback(uint32_t currentProviderId, uint32_t issuerEventId, + uint8_t tariffType, uint32_t proposedProviderId, + uint32_t providerChangeImplementationTime, + uint32_t providerChangeControl, uint8_t * proposedProviderName, + uint8_t * proposedProviderContactDetails); +/** @brief Device Management Cluster Publish Change Of Tenancy + * + * + * + * @param providerId Ver.: always + * @param issuerEventId Ver.: always + * @param tariffType Ver.: always + * @param implementationDateTime Ver.: always + * @param proposedTenancyChangeControl Ver.: always + */ +bool emberAfDeviceManagementClusterPublishChangeOfTenancyCallback(uint32_t providerId, uint32_t issuerEventId, uint8_t tariffType, + uint32_t implementationDateTime, + uint32_t proposedTenancyChangeControl); +/** @brief Device Management Cluster Report Event Configuration + * + * + * + * @param commandIndex Ver.: always + * @param totalCommands Ver.: always + * @param eventConfigurationPayload Ver.: always + */ +bool emberAfDeviceManagementClusterReportEventConfigurationCallback(uint8_t commandIndex, uint8_t totalCommands, + uint8_t * eventConfigurationPayload); +/** @brief Device Management Cluster Request New Password + * + * + * + * @param passwordType Ver.: always + */ +bool emberAfDeviceManagementClusterRequestNewPasswordCallback(uint8_t passwordType); +/** @brief Device Management Cluster Request New Password Response + * + * + * + * @param issuerEventId Ver.: always + * @param implementationDateTime Ver.: always + * @param durationInMinutes Ver.: always + * @param passwordType Ver.: always + * @param password Ver.: always + */ +bool emberAfDeviceManagementClusterRequestNewPasswordResponseCallback(uint32_t issuerEventId, uint32_t implementationDateTime, + uint16_t durationInMinutes, uint8_t passwordType, + uint8_t * password); +/** @brief Device Management Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDeviceManagementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Device Management Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDeviceManagementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Device Management Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDeviceManagementClusterServerInitCallback(uint8_t endpoint); +/** @brief Device Management Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDeviceManagementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Device Management Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDeviceManagementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Device Management Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDeviceManagementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Device Management Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDeviceManagementClusterServerTickCallback(uint8_t endpoint); +/** @brief Device Management Cluster Set Event Configuration + * + * + * + * @param issuerEventId Ver.: always + * @param startDateTime Ver.: always + * @param eventConfiguration Ver.: always + * @param configurationControl Ver.: always + * @param eventConfigurationPayload Ver.: always + */ +bool emberAfDeviceManagementClusterSetEventConfigurationCallback(uint32_t issuerEventId, uint32_t startDateTime, + uint8_t eventConfiguration, uint8_t configurationControl, + uint8_t * eventConfigurationPayload); +/** @brief Device Management Cluster Update C I N + * + * + * + * @param issuerEventId Ver.: always + * @param implementationTime Ver.: always + * @param providerId Ver.: always + * @param customerIdNumber Ver.: always + */ +bool emberAfDeviceManagementClusterUpdateCINCallback(uint32_t issuerEventId, uint32_t implementationTime, uint32_t providerId, + uint8_t * customerIdNumber); +/** @brief Device Management Cluster Update Site Id + * + * + * + * @param issuerEventId Ver.: always + * @param siteIdTime Ver.: always + * @param providerId Ver.: always + * @param siteId Ver.: always + */ +bool emberAfDeviceManagementClusterUpdateSiteIdCallback(uint32_t issuerEventId, uint32_t siteIdTime, uint32_t providerId, + uint8_t * siteId); + +/** @} END Device Management Cluster Callbacks */ + +/** @name Events Cluster Callbacks */ +// @{ + +/** @brief Events Cluster Clear Event Log Request + * + * + * + * @param logId Ver.: always + */ +bool emberAfEventsClusterClearEventLogRequestCallback(uint8_t logId); +/** @brief Events Cluster Clear Event Log Response + * + * + * + * @param clearedEventsLogs Ver.: always + */ +bool emberAfEventsClusterClearEventLogResponseCallback(uint8_t clearedEventsLogs); +/** @brief Events Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEventsClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Events Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEventsClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Events Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEventsClusterClientInitCallback(uint8_t endpoint); +/** @brief Events Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEventsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Events Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEventsClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Events Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEventsClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Events Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEventsClusterClientTickCallback(uint8_t endpoint); +/** @brief Events Cluster Get Event Log + * + * + * + * @param eventControlLogId Ver.: always + * @param eventId Ver.: always + * @param startTime Ver.: always + * @param endTime Ver.: always + * @param numberOfEvents Ver.: always + * @param eventOffset Ver.: always + */ +bool emberAfEventsClusterGetEventLogCallback(uint8_t eventControlLogId, uint16_t eventId, uint32_t startTime, uint32_t endTime, + uint8_t numberOfEvents, uint16_t eventOffset); +/** @brief Events Cluster Publish Event + * + * + * + * @param logId Ver.: always + * @param eventId Ver.: always + * @param eventTime Ver.: always + * @param eventControl Ver.: always + * @param eventData Ver.: always + */ +bool emberAfEventsClusterPublishEventCallback(uint8_t logId, uint16_t eventId, uint32_t eventTime, uint8_t eventControl, + uint8_t * eventData); +/** @brief Events Cluster Publish Event Log + * + * + * + * @param totalNumberOfEvents Ver.: always + * @param commandIndex Ver.: always + * @param totalCommands Ver.: always + * @param logPayloadControl Ver.: always + * @param logPayload Ver.: always + */ +bool emberAfEventsClusterPublishEventLogCallback(uint16_t totalNumberOfEvents, uint8_t commandIndex, uint8_t totalCommands, + uint8_t logPayloadControl, uint8_t * logPayload); +/** @brief Events Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfEventsClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Events Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfEventsClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Events Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfEventsClusterServerInitCallback(uint8_t endpoint); +/** @brief Events Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfEventsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Events Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfEventsClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Events Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfEventsClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Events Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfEventsClusterServerTickCallback(uint8_t endpoint); + +/** @} END Events Cluster Callbacks */ + +/** @name MDU Pairing Cluster Callbacks */ +// @{ + +/** @brief MDU Pairing Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMduPairingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief MDU Pairing Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMduPairingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief MDU Pairing Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMduPairingClusterClientInitCallback(uint8_t endpoint); +/** @brief MDU Pairing Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMduPairingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief MDU Pairing Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMduPairingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief MDU Pairing Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMduPairingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief MDU Pairing Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMduPairingClusterClientTickCallback(uint8_t endpoint); +/** @brief MDU Pairing Cluster Pairing Request + * + * + * + * @param localPairingInformationVersion Ver.: always + * @param eui64OfRequestingDevice Ver.: always + */ +bool emberAfMduPairingClusterPairingRequestCallback(uint32_t localPairingInformationVersion, uint8_t * eui64OfRequestingDevice); +/** @brief MDU Pairing Cluster Pairing Response + * + * + * + * @param pairingInformationVersion Ver.: always + * @param totalNumberOfDevices Ver.: always + * @param commandIndex Ver.: always + * @param totalNumberOfCommands Ver.: always + * @param eui64s Ver.: always + */ +bool emberAfMduPairingClusterPairingResponseCallback(uint32_t pairingInformationVersion, uint8_t totalNumberOfDevices, + uint8_t commandIndex, uint8_t totalNumberOfCommands, uint8_t * eui64s); +/** @brief MDU Pairing Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMduPairingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief MDU Pairing Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMduPairingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief MDU Pairing Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMduPairingClusterServerInitCallback(uint8_t endpoint); +/** @brief MDU Pairing Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMduPairingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief MDU Pairing Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMduPairingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief MDU Pairing Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMduPairingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief MDU Pairing Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMduPairingClusterServerTickCallback(uint8_t endpoint); + +/** @} END MDU Pairing Cluster Callbacks */ + +/** @name Sub-GHz Cluster Callbacks */ +// @{ + +/** @brief Sub-GHz Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSubGhzClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Sub-GHz Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSubGhzClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Sub-GHz Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSubGhzClusterClientInitCallback(uint8_t endpoint); +/** @brief Sub-GHz Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSubGhzClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sub-GHz Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSubGhzClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Sub-GHz Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSubGhzClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Sub-GHz Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSubGhzClusterClientTickCallback(uint8_t endpoint); +/** @brief Sub-GHz Cluster Get Suspend Zcl Messages Status + * + * + * + */ +bool emberAfSubGhzClusterGetSuspendZclMessagesStatusCallback(void); +/** @brief Sub-GHz Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSubGhzClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Sub-GHz Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSubGhzClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Sub-GHz Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSubGhzClusterServerInitCallback(uint8_t endpoint); +/** @brief Sub-GHz Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSubGhzClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sub-GHz Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSubGhzClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Sub-GHz Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSubGhzClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Sub-GHz Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSubGhzClusterServerTickCallback(uint8_t endpoint); +/** @brief Sub-GHz Cluster Suspend Zcl Messages + * + * + * + * @param period Ver.: always + */ +bool emberAfSubGhzClusterSuspendZclMessagesCallback(uint8_t period); + +/** @} END Sub-GHz Cluster Callbacks */ + +/** @name Key Establishment Cluster Callbacks */ +// @{ + +/** @brief Key Establishment Cluster Client Command Received + * + * This function is called by the application framework when a server-to-client + * key establishment command is received but has yet to be handled by the + * framework code. This function should return a bool value indicating whether + * the command has been handled by the application code and should not be + * further processed by the framework. + * + * @param cmd Ver.: always + */ +bool emberAfKeyEstablishmentClusterClientCommandReceivedCallback(EmberAfClusterCommand * cmd); +/** @brief Key Establishment Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfKeyEstablishmentClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Key Establishment Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfKeyEstablishmentClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Key Establishment Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfKeyEstablishmentClusterClientInitCallback(uint8_t endpoint); +/** @brief Key Establishment Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfKeyEstablishmentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Key Establishment Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfKeyEstablishmentClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Key Establishment Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfKeyEstablishmentClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Key Establishment Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfKeyEstablishmentClusterClientTickCallback(uint8_t endpoint); +/** @brief Key Establishment Cluster Confirm Key Data Request + * + * + * + * @param secureMessageAuthenticationCode Ver.: always + */ +bool emberAfKeyEstablishmentClusterConfirmKeyDataRequestCallback(uint8_t * secureMessageAuthenticationCode); +/** @brief Key Establishment Cluster Confirm Key Data Response + * + * + * + * @param secureMessageAuthenticationCode Ver.: always + */ +bool emberAfKeyEstablishmentClusterConfirmKeyDataResponseCallback(uint8_t * secureMessageAuthenticationCode); +/** @brief Key Establishment Cluster Ephemeral Data Request + * + * + * + * @param ephemeralData Ver.: always + */ +bool emberAfKeyEstablishmentClusterEphemeralDataRequestCallback(uint8_t * ephemeralData); +/** @brief Key Establishment Cluster Ephemeral Data Response + * + * + * + * @param ephemeralData Ver.: always + */ +bool emberAfKeyEstablishmentClusterEphemeralDataResponseCallback(uint8_t * ephemeralData); +/** @brief Key Establishment Cluster Initiate Key Establishment Request + * + * + * + * @param keyEstablishmentSuite Ver.: always + * @param ephemeralDataGenerateTime Ver.: always + * @param confirmKeyGenerateTime Ver.: always + * @param identity Ver.: always + */ +bool emberAfKeyEstablishmentClusterInitiateKeyEstablishmentRequestCallback(uint16_t keyEstablishmentSuite, + uint8_t ephemeralDataGenerateTime, + uint8_t confirmKeyGenerateTime, uint8_t * identity); +/** @brief Key Establishment Cluster Initiate Key Establishment Response + * + * + * + * @param requestedKeyEstablishmentSuite Ver.: always + * @param ephemeralDataGenerateTime Ver.: always + * @param confirmKeyGenerateTime Ver.: always + * @param identity Ver.: always + */ +bool emberAfKeyEstablishmentClusterInitiateKeyEstablishmentResponseCallback(uint16_t requestedKeyEstablishmentSuite, + uint8_t ephemeralDataGenerateTime, + uint8_t confirmKeyGenerateTime, uint8_t * identity); +/** @brief Key Establishment Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfKeyEstablishmentClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Key Establishment Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfKeyEstablishmentClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Key Establishment Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfKeyEstablishmentClusterServerInitCallback(uint8_t endpoint); +/** @brief Key Establishment Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfKeyEstablishmentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Key Establishment Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfKeyEstablishmentClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Key Establishment Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfKeyEstablishmentClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Key Establishment Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfKeyEstablishmentClusterServerTickCallback(uint8_t endpoint); +/** @brief Key Establishment Cluster Terminate Key Establishment + * + * + * + * @param statusCode Ver.: always + * @param waitTime Ver.: always + * @param keyEstablishmentSuite Ver.: always + */ +bool emberAfKeyEstablishmentClusterTerminateKeyEstablishmentCallback(uint8_t statusCode, uint8_t waitTime, + uint16_t keyEstablishmentSuite); +/** @brief Key Establishment Cluster Server Command Received + * + * This function is called by the application framework when a client-to-server + * key establishment command is received but has yet to be handled by the + * framework code. This function should return a bool value indicating whether + * the command has been handled by the application code and should not be + * further processed by the framework. + * + * @param cmd Ver.: always + */ +bool emberAfKeyEstablishmentClusterServerCommandReceivedCallback(EmberAfClusterCommand * cmd); + +/** @} END Key Establishment Cluster Callbacks */ + +/** @name Information Cluster Callbacks */ +// @{ + +/** @brief Information Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfInformationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Information Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfInformationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Information Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfInformationClusterClientInitCallback(uint8_t endpoint); +/** @brief Information Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfInformationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Information Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfInformationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Information Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfInformationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Information Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfInformationClusterClientTickCallback(uint8_t endpoint); +/** @brief Information Cluster Configure Delivery Enable + * + * + * + * @param enable Ver.: always + */ +bool emberAfInformationClusterConfigureDeliveryEnableCallback(uint8_t enable); +/** @brief Information Cluster Configure Node Description + * + * + * + * @param description Ver.: always + */ +bool emberAfInformationClusterConfigureNodeDescriptionCallback(uint8_t * description); +/** @brief Information Cluster Configure Push Information Timer + * + * + * + * @param timer Ver.: always + */ +bool emberAfInformationClusterConfigurePushInformationTimerCallback(uint32_t timer); +/** @brief Information Cluster Configure Set Root Id + * + * + * + * @param rootId Ver.: always + */ +bool emberAfInformationClusterConfigureSetRootIdCallback(uint16_t rootId); +/** @brief Information Cluster Delete + * + * + * + * @param deletionOptions Ver.: always + * @param contentIds Ver.: always + */ +bool emberAfInformationClusterDeleteCallback(uint8_t deletionOptions, uint8_t * contentIds); +/** @brief Information Cluster Delete Response + * + * + * + * @param notificationList Ver.: always + */ +bool emberAfInformationClusterDeleteResponseCallback(uint8_t * notificationList); +/** @brief Information Cluster Push Information + * + * + * + * @param contents Ver.: always + */ +bool emberAfInformationClusterPushInformationCallback(uint8_t * contents); +/** @brief Information Cluster Push Information Response + * + * + * + * @param notificationList Ver.: always + */ +bool emberAfInformationClusterPushInformationResponseCallback(uint8_t * notificationList); +/** @brief Information Cluster Request Information + * + * + * + * @param inquiryId Ver.: always + * @param dataTypeId Ver.: always + * @param requestInformationPayload Ver.: always + */ +bool emberAfInformationClusterRequestInformationCallback(uint8_t inquiryId, uint8_t dataTypeId, + uint8_t * requestInformationPayload); +/** @brief Information Cluster Request Information Response + * + * + * + * @param number Ver.: always + * @param buffer Ver.: always + */ +bool emberAfInformationClusterRequestInformationResponseCallback(uint8_t number, uint8_t * buffer); +/** @brief Information Cluster Request Preference Confirmation + * + * + * + * @param statusFeedbackList Ver.: always + */ +bool emberAfInformationClusterRequestPreferenceConfirmationCallback(uint8_t * statusFeedbackList); +/** @brief Information Cluster Request Preference Response + * + * + * + * @param statusFeedback Ver.: always + * @param preferenceType Ver.: always + * @param preferencePayload Ver.: always + */ +bool emberAfInformationClusterRequestPreferenceResponseCallback(uint8_t statusFeedback, uint16_t preferenceType, + uint8_t * preferencePayload); +/** @brief Information Cluster Send Preference + * + * + * + * @param preferenceType Ver.: always + * @param preferencePayload Ver.: always + */ +bool emberAfInformationClusterSendPreferenceCallback(uint16_t preferenceType, uint8_t * preferencePayload); +/** @brief Information Cluster Send Preference Response + * + * + * + * @param statusFeedbackList Ver.: always + */ +bool emberAfInformationClusterSendPreferenceResponseCallback(uint8_t * statusFeedbackList); +/** @brief Information Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfInformationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Information Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfInformationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Information Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfInformationClusterServerInitCallback(uint8_t endpoint); +/** @brief Information Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfInformationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Information Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfInformationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Information Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfInformationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Information Cluster Server Request Preference + * + * + * + */ +bool emberAfInformationClusterServerRequestPreferenceCallback(void); +/** @brief Information Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfInformationClusterServerTickCallback(uint8_t endpoint); +/** @brief Information Cluster Update + * + * + * + * @param accessControl Ver.: always + * @param option Ver.: always + * @param contents Ver.: always + */ +bool emberAfInformationClusterUpdateCallback(uint8_t accessControl, uint8_t option, uint8_t * contents); +/** @brief Information Cluster Update Response + * + * + * + * @param notificationList Ver.: always + */ +bool emberAfInformationClusterUpdateResponseCallback(uint8_t * notificationList); + +/** @} END Information Cluster Callbacks */ + +/** @name Data Sharing Cluster Callbacks */ +// @{ + +/** @brief Data Sharing Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDataSharingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Data Sharing Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDataSharingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Data Sharing Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDataSharingClusterClientInitCallback(uint8_t endpoint); +/** @brief Data Sharing Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDataSharingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Data Sharing Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDataSharingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Data Sharing Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDataSharingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Data Sharing Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDataSharingClusterClientTickCallback(uint8_t endpoint); +/** @brief Data Sharing Cluster File Transmission + * + * + * + * @param transmitOptions Ver.: always + * @param buffer Ver.: always + */ +bool emberAfDataSharingClusterFileTransmissionCallback(uint8_t transmitOptions, uint8_t * buffer); +/** @brief Data Sharing Cluster Modify File Request + * + * + * + * @param fileIndex Ver.: always + * @param fileStartPosition Ver.: always + * @param octetCount Ver.: always + */ +bool emberAfDataSharingClusterModifyFileRequestCallback(uint16_t fileIndex, uint32_t fileStartPosition, uint32_t octetCount); +/** @brief Data Sharing Cluster Modify Record Request + * + * + * + * @param fileIndex Ver.: always + * @param fileStartRecord Ver.: always + * @param recordCount Ver.: always + */ +bool emberAfDataSharingClusterModifyRecordRequestCallback(uint16_t fileIndex, uint16_t fileStartRecord, uint16_t recordCount); +/** @brief Data Sharing Cluster Read File Request + * + * + * + * @param fileIndex Ver.: always + * @param fileStartPositionAndRequestedOctetCount Ver.: always + */ +bool emberAfDataSharingClusterReadFileRequestCallback(uint16_t fileIndex, uint8_t * fileStartPositionAndRequestedOctetCount); +/** @brief Data Sharing Cluster Read Record Request + * + * + * + * @param fileIndex Ver.: always + * @param fileStartRecordAndRequestedRecordCount Ver.: always + */ +bool emberAfDataSharingClusterReadRecordRequestCallback(uint16_t fileIndex, uint8_t * fileStartRecordAndRequestedRecordCount); +/** @brief Data Sharing Cluster Record Transmission + * + * + * + * @param transmitOptions Ver.: always + * @param buffer Ver.: always + */ +bool emberAfDataSharingClusterRecordTransmissionCallback(uint8_t transmitOptions, uint8_t * buffer); +/** @brief Data Sharing Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDataSharingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Data Sharing Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDataSharingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Data Sharing Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDataSharingClusterServerInitCallback(uint8_t endpoint); +/** @brief Data Sharing Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDataSharingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Data Sharing Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDataSharingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Data Sharing Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDataSharingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Data Sharing Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDataSharingClusterServerTickCallback(uint8_t endpoint); +/** @brief Data Sharing Cluster Write File Request + * + * + * + * @param writeOptions Ver.: always + * @param fileSize Ver.: always + */ +bool emberAfDataSharingClusterWriteFileRequestCallback(uint8_t writeOptions, uint8_t * fileSize); +/** @brief Data Sharing Cluster Write File Response + * + * + * + * @param status Ver.: always + * @param fileIndex Ver.: always + */ +bool emberAfDataSharingClusterWriteFileResponseCallback(uint8_t status, uint8_t * fileIndex); + +/** @} END Data Sharing Cluster Callbacks */ + +/** @name Gaming Cluster Callbacks */ +// @{ + +/** @brief Gaming Cluster Action Control + * + * + * + * @param actions Ver.: always + */ +bool emberAfGamingClusterActionControlCallback(uint32_t actions); +/** @brief Gaming Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGamingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Gaming Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGamingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Gaming Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGamingClusterClientInitCallback(uint8_t endpoint); +/** @brief Gaming Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGamingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Gaming Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGamingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Gaming Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGamingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Gaming Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGamingClusterClientTickCallback(uint8_t endpoint); +/** @brief Gaming Cluster Download Game + * + * + * + */ +bool emberAfGamingClusterDownloadGameCallback(void); +/** @brief Gaming Cluster End Game + * + * + * + */ +bool emberAfGamingClusterEndGameCallback(void); +/** @brief Gaming Cluster Game Announcement + * + * + * + * @param gameId Ver.: always + * @param gameMaster Ver.: always + * @param listOfGame Ver.: always + */ +bool emberAfGamingClusterGameAnnouncementCallback(uint16_t gameId, uint8_t gameMaster, uint8_t * listOfGame); +/** @brief Gaming Cluster General Response + * + * + * + * @param commandId Ver.: always + * @param status Ver.: always + * @param message Ver.: always + */ +bool emberAfGamingClusterGeneralResponseCallback(uint8_t commandId, uint8_t status, uint8_t * message); +/** @brief Gaming Cluster Join Game + * + * + * + * @param gameId Ver.: always + * @param joinAsMaster Ver.: always + * @param nameOfGame Ver.: always + */ +bool emberAfGamingClusterJoinGameCallback(uint16_t gameId, uint8_t joinAsMaster, uint8_t * nameOfGame); +/** @brief Gaming Cluster Pause Game + * + * + * + */ +bool emberAfGamingClusterPauseGameCallback(void); +/** @brief Gaming Cluster Quit Game + * + * + * + */ +bool emberAfGamingClusterQuitGameCallback(void); +/** @brief Gaming Cluster Resume Game + * + * + * + */ +bool emberAfGamingClusterResumeGameCallback(void); +/** @brief Gaming Cluster Search Game + * + * + * + * @param specificGame Ver.: always + * @param gameId Ver.: always + */ +bool emberAfGamingClusterSearchGameCallback(uint8_t specificGame, uint16_t gameId); +/** @brief Gaming Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfGamingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Gaming Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfGamingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Gaming Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfGamingClusterServerInitCallback(uint8_t endpoint); +/** @brief Gaming Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfGamingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Gaming Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfGamingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Gaming Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfGamingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Gaming Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfGamingClusterServerTickCallback(uint8_t endpoint); +/** @brief Gaming Cluster Start Game + * + * + * + */ +bool emberAfGamingClusterStartGameCallback(void); +/** @brief Gaming Cluster Start Over + * + * + * + */ +bool emberAfGamingClusterStartOverCallback(void); + +/** @} END Gaming Cluster Callbacks */ + +/** @name Data Rate Control Cluster Callbacks */ +// @{ + +/** @brief Data Rate Control Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDataRateControlClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Data Rate Control Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDataRateControlClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Data Rate Control Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDataRateControlClusterClientInitCallback(uint8_t endpoint); +/** @brief Data Rate Control Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDataRateControlClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Data Rate Control Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDataRateControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Data Rate Control Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDataRateControlClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Data Rate Control Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDataRateControlClusterClientTickCallback(uint8_t endpoint); +/** @brief Data Rate Control Cluster Data Rate Control + * + * + * + * @param originatorAddress Ver.: always + * @param destinationAddress Ver.: always + * @param dataRate Ver.: always + */ +bool emberAfDataRateControlClusterDataRateControlCallback(uint16_t originatorAddress, uint16_t destinationAddress, + uint8_t dataRate); +/** @brief Data Rate Control Cluster Data Rate Notification + * + * + * + * @param originatorAddress Ver.: always + * @param destinationAddress Ver.: always + * @param dataRate Ver.: always + */ +bool emberAfDataRateControlClusterDataRateNotificationCallback(uint16_t originatorAddress, uint16_t destinationAddress, + uint8_t dataRate); +/** @brief Data Rate Control Cluster Path Creation + * + * + * + * @param originatorAddress Ver.: always + * @param destinationAddress Ver.: always + * @param dataRate Ver.: always + */ +bool emberAfDataRateControlClusterPathCreationCallback(uint16_t originatorAddress, uint16_t destinationAddress, uint8_t dataRate); +/** @brief Data Rate Control Cluster Path Deletion + * + * + * + * @param originatorAddress Ver.: always + * @param destinationAddress Ver.: always + */ +bool emberAfDataRateControlClusterPathDeletionCallback(uint16_t originatorAddress, uint16_t destinationAddress); +/** @brief Data Rate Control Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDataRateControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Data Rate Control Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDataRateControlClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Data Rate Control Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDataRateControlClusterServerInitCallback(uint8_t endpoint); +/** @brief Data Rate Control Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDataRateControlClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Data Rate Control Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDataRateControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Data Rate Control Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDataRateControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Data Rate Control Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDataRateControlClusterServerTickCallback(uint8_t endpoint); + +/** @} END Data Rate Control Cluster Callbacks */ + +/** @name Voice over ZigBee Cluster Callbacks */ +// @{ + +/** @brief Voice over ZigBee Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Voice over ZigBee Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Voice over ZigBee Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientInitCallback(uint8_t endpoint); +/** @brief Voice over ZigBee Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Voice over ZigBee Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Voice over ZigBee Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfVoiceOverZigbeeClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Voice over ZigBee Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfVoiceOverZigbeeClusterClientTickCallback(uint8_t endpoint); +/** @brief Voice over ZigBee Cluster Control + * + * + * + * @param controlType Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterControlCallback(uint8_t controlType); +/** @brief Voice over ZigBee Cluster Control Response + * + * + * + * @param ackNack Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterControlResponseCallback(uint8_t ackNack); +/** @brief Voice over ZigBee Cluster Establishment Request + * + * + * + * @param flag Ver.: always + * @param codecType Ver.: always + * @param sampFreq Ver.: always + * @param codecRate Ver.: always + * @param serviceType Ver.: always + * @param buffer Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterEstablishmentRequestCallback(uint8_t flag, uint8_t codecType, uint8_t sampFreq, uint8_t codecRate, + uint8_t serviceType, uint8_t * buffer); +/** @brief Voice over ZigBee Cluster Establishment Response + * + * + * + * @param ackNack Ver.: always + * @param codecType Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterEstablishmentResponseCallback(uint8_t ackNack, uint8_t codecType); +/** @brief Voice over ZigBee Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Voice over ZigBee Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Voice over ZigBee Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerInitCallback(uint8_t endpoint); +/** @brief Voice over ZigBee Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Voice over ZigBee Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Voice over ZigBee Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfVoiceOverZigbeeClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Voice over ZigBee Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfVoiceOverZigbeeClusterServerTickCallback(uint8_t endpoint); +/** @brief Voice over ZigBee Cluster Voice Transmission + * + * + * + * @param voiceData Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterVoiceTransmissionCallback(uint8_t * voiceData); +/** @brief Voice over ZigBee Cluster Voice Transmission Completion + * + * + * + */ +bool emberAfVoiceOverZigbeeClusterVoiceTransmissionCompletionCallback(void); +/** @brief Voice over ZigBee Cluster Voice Transmission Response + * + * + * + * @param sequenceNumber Ver.: always + * @param errorFlag Ver.: always + */ +bool emberAfVoiceOverZigbeeClusterVoiceTransmissionResponseCallback(uint8_t sequenceNumber, uint8_t errorFlag); + +/** @} END Voice over ZigBee Cluster Callbacks */ + +/** @name Chatting Cluster Callbacks */ +// @{ + +/** @brief Chatting Cluster Chat Message + * + * + * + * @param destinationUid Ver.: always + * @param sourceUid Ver.: always + * @param cid Ver.: always + * @param nickname Ver.: always + * @param message Ver.: always + */ +bool emberAfChattingClusterChatMessageCallback(uint16_t destinationUid, uint16_t sourceUid, uint16_t cid, uint8_t * nickname, + uint8_t * message); +/** @brief Chatting Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChattingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Chatting Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChattingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Chatting Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChattingClusterClientInitCallback(uint8_t endpoint); +/** @brief Chatting Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChattingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chatting Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChattingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Chatting Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChattingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Chatting Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChattingClusterClientTickCallback(uint8_t endpoint); +/** @brief Chatting Cluster Get Node Information Request + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + */ +bool emberAfChattingClusterGetNodeInformationRequestCallback(uint16_t cid, uint16_t uid); +/** @brief Chatting Cluster Get Node Information Response + * + * + * + * @param status Ver.: always + * @param cid Ver.: always + * @param uid Ver.: always + * @param addressEndpointAndNickname Ver.: always + */ +bool emberAfChattingClusterGetNodeInformationResponseCallback(uint8_t status, uint16_t cid, uint16_t uid, + uint8_t * addressEndpointAndNickname); +/** @brief Chatting Cluster Join Chat Request + * + * + * + * @param uid Ver.: always + * @param nickname Ver.: always + * @param cid Ver.: always + */ +bool emberAfChattingClusterJoinChatRequestCallback(uint16_t uid, uint8_t * nickname, uint16_t cid); +/** @brief Chatting Cluster Join Chat Response + * + * + * + * @param status Ver.: always + * @param cid Ver.: always + * @param chatParticipantList Ver.: always + */ +bool emberAfChattingClusterJoinChatResponseCallback(uint8_t status, uint16_t cid, uint8_t * chatParticipantList); +/** @brief Chatting Cluster Leave Chat Request + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + */ +bool emberAfChattingClusterLeaveChatRequestCallback(uint16_t cid, uint16_t uid); +/** @brief Chatting Cluster Search Chat Request + * + * + * + */ +bool emberAfChattingClusterSearchChatRequestCallback(void); +/** @brief Chatting Cluster Search Chat Response + * + * + * + * @param options Ver.: always + * @param chatRoomList Ver.: always + */ +bool emberAfChattingClusterSearchChatResponseCallback(uint8_t options, uint8_t * chatRoomList); +/** @brief Chatting Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfChattingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Chatting Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfChattingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Chatting Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfChattingClusterServerInitCallback(uint8_t endpoint); +/** @brief Chatting Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfChattingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Chatting Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfChattingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Chatting Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfChattingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Chatting Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfChattingClusterServerTickCallback(uint8_t endpoint); +/** @brief Chatting Cluster Start Chat Request + * + * + * + * @param name Ver.: always + * @param uid Ver.: always + * @param nickname Ver.: always + */ +bool emberAfChattingClusterStartChatRequestCallback(uint8_t * name, uint16_t uid, uint8_t * nickname); +/** @brief Chatting Cluster Start Chat Response + * + * + * + * @param status Ver.: always + * @param cid Ver.: always + */ +bool emberAfChattingClusterStartChatResponseCallback(uint8_t status, uint16_t cid); +/** @brief Chatting Cluster Switch Chairman Confirm + * + * + * + * @param cid Ver.: always + * @param nodeInformationList Ver.: always + */ +bool emberAfChattingClusterSwitchChairmanConfirmCallback(uint16_t cid, uint8_t * nodeInformationList); +/** @brief Chatting Cluster Switch Chairman Notification + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + * @param address Ver.: always + * @param endpoint Ver.: always + */ +bool emberAfChattingClusterSwitchChairmanNotificationCallback(uint16_t cid, uint16_t uid, uint16_t address, uint8_t endpoint); +/** @brief Chatting Cluster Switch Chairman Request + * + * + * + * @param cid Ver.: always + */ +bool emberAfChattingClusterSwitchChairmanRequestCallback(uint16_t cid); +/** @brief Chatting Cluster Switch Chairman Response + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + */ +bool emberAfChattingClusterSwitchChairmanResponseCallback(uint16_t cid, uint16_t uid); +/** @brief Chatting Cluster User Joined + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + * @param nickname Ver.: always + */ +bool emberAfChattingClusterUserJoinedCallback(uint16_t cid, uint16_t uid, uint8_t * nickname); +/** @brief Chatting Cluster User Left + * + * + * + * @param cid Ver.: always + * @param uid Ver.: always + * @param nickname Ver.: always + */ +bool emberAfChattingClusterUserLeftCallback(uint16_t cid, uint16_t uid, uint8_t * nickname); + +/** @} END Chatting Cluster Callbacks */ + +/** @name Payment Cluster Callbacks */ +// @{ + +/** @brief Payment Cluster Accept Payment + * + * + * + * @param userId Ver.: always + * @param userType Ver.: always + * @param serviceId Ver.: always + * @param goodId Ver.: always + */ +bool emberAfPaymentClusterAcceptPaymentCallback(uint8_t * userId, uint16_t userType, uint16_t serviceId, uint8_t * goodId); +/** @brief Payment Cluster Buy Confirm + * + * + * + * @param serialNumber Ver.: always + * @param currency Ver.: always + * @param priceTrailingDigit Ver.: always + * @param price Ver.: always + * @param timestamp Ver.: always + * @param transId Ver.: always + * @param transStatus Ver.: always + */ +bool emberAfPaymentClusterBuyConfirmCallback(uint8_t * serialNumber, uint32_t currency, uint8_t priceTrailingDigit, uint32_t price, + uint8_t * timestamp, uint16_t transId, uint8_t transStatus); +/** @brief Payment Cluster Buy Request + * + * + * + * @param userId Ver.: always + * @param userType Ver.: always + * @param serviceId Ver.: always + * @param goodId Ver.: always + */ +bool emberAfPaymentClusterBuyRequestCallback(uint8_t * userId, uint16_t userType, uint16_t serviceId, uint8_t * goodId); +/** @brief Payment Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPaymentClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Payment Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPaymentClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Payment Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPaymentClusterClientInitCallback(uint8_t endpoint); +/** @brief Payment Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPaymentClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Payment Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPaymentClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Payment Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPaymentClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Payment Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPaymentClusterClientTickCallback(uint8_t endpoint); +/** @brief Payment Cluster Payment Confirm + * + * + * + * @param serialNumber Ver.: always + * @param transId Ver.: always + * @param transStatus Ver.: always + */ +bool emberAfPaymentClusterPaymentConfirmCallback(uint8_t * serialNumber, uint16_t transId, uint8_t transStatus); +/** @brief Payment Cluster Receipt Delivery + * + * + * + * @param serialNumber Ver.: always + * @param currency Ver.: always + * @param priceTrailingDigit Ver.: always + * @param price Ver.: always + * @param timestamp Ver.: always + */ +bool emberAfPaymentClusterReceiptDeliveryCallback(uint8_t * serialNumber, uint32_t currency, uint8_t priceTrailingDigit, + uint32_t price, uint8_t * timestamp); +/** @brief Payment Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfPaymentClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Payment Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfPaymentClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Payment Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfPaymentClusterServerInitCallback(uint8_t endpoint); +/** @brief Payment Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfPaymentClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Payment Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfPaymentClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Payment Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfPaymentClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Payment Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfPaymentClusterServerTickCallback(uint8_t endpoint); +/** @brief Payment Cluster Transaction End + * + * + * + * @param serialNumber Ver.: always + * @param status Ver.: always + */ +bool emberAfPaymentClusterTransactionEndCallback(uint8_t * serialNumber, uint8_t status); + +/** @} END Payment Cluster Callbacks */ + +/** @name Billing Cluster Callbacks */ +// @{ + +/** @brief Billing Cluster Bill Status Notification + * + * + * + * @param userId Ver.: always + * @param status Ver.: always + */ +bool emberAfBillingClusterBillStatusNotificationCallback(uint8_t * userId, uint8_t status); +/** @brief Billing Cluster Check Bill Status + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterCheckBillStatusCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); +/** @brief Billing Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBillingClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Billing Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBillingClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Billing Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBillingClusterClientInitCallback(uint8_t endpoint); +/** @brief Billing Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBillingClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Billing Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBillingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Billing Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBillingClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Billing Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBillingClusterClientTickCallback(uint8_t endpoint); +/** @brief Billing Cluster Send Bill Record + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + * @param timestamp Ver.: always + * @param duration Ver.: always + */ +bool emberAfBillingClusterSendBillRecordCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId, + uint8_t * timestamp, uint16_t duration); +/** @brief Billing Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfBillingClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Billing Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfBillingClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Billing Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfBillingClusterServerInitCallback(uint8_t endpoint); +/** @brief Billing Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfBillingClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Billing Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfBillingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Billing Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfBillingClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Billing Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfBillingClusterServerTickCallback(uint8_t endpoint); +/** @brief Billing Cluster Session Keep Alive + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterSessionKeepAliveCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); +/** @brief Billing Cluster Start Billing Session + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterStartBillingSessionCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); +/** @brief Billing Cluster Stop Billing Session + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterStopBillingSessionCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); +/** @brief Billing Cluster Subscribe + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterSubscribeCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); +/** @brief Billing Cluster Unsubscribe + * + * + * + * @param userId Ver.: always + * @param serviceId Ver.: always + * @param serviceProviderId Ver.: always + */ +bool emberAfBillingClusterUnsubscribeCallback(uint8_t * userId, uint16_t serviceId, uint16_t serviceProviderId); + +/** @} END Billing Cluster Callbacks */ + +/** @name Appliance Identification Cluster Callbacks */ +// @{ + +/** @brief Appliance Identification Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceIdentificationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Appliance Identification Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceIdentificationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Appliance Identification Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceIdentificationClusterClientInitCallback(uint8_t endpoint); +/** @brief Appliance Identification Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceIdentificationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Identification Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceIdentificationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Appliance Identification Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceIdentificationClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Appliance Identification Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceIdentificationClusterClientTickCallback(uint8_t endpoint); +/** @brief Appliance Identification Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceIdentificationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Appliance Identification Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceIdentificationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Appliance Identification Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceIdentificationClusterServerInitCallback(uint8_t endpoint); +/** @brief Appliance Identification Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceIdentificationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Identification Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceIdentificationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Appliance Identification Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceIdentificationClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Appliance Identification Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceIdentificationClusterServerTickCallback(uint8_t endpoint); + +/** @} END Appliance Identification Cluster Callbacks */ + +/** @name Meter Identification Cluster Callbacks */ +// @{ + +/** @brief Meter Identification Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMeterIdentificationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Meter Identification Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMeterIdentificationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Meter Identification Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMeterIdentificationClusterClientInitCallback(uint8_t endpoint); +/** @brief Meter Identification Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMeterIdentificationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Meter Identification Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMeterIdentificationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Meter Identification Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMeterIdentificationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Meter Identification Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMeterIdentificationClusterClientTickCallback(uint8_t endpoint); +/** @brief Meter Identification Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMeterIdentificationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Meter Identification Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMeterIdentificationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Meter Identification Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMeterIdentificationClusterServerInitCallback(uint8_t endpoint); +/** @brief Meter Identification Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMeterIdentificationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Meter Identification Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMeterIdentificationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Meter Identification Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMeterIdentificationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Meter Identification Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMeterIdentificationClusterServerTickCallback(uint8_t endpoint); + +/** @} END Meter Identification Cluster Callbacks */ + +/** @name Appliance Events and Alert Cluster Callbacks */ +// @{ + +/** @brief Appliance Events and Alert Cluster Alerts Notification + * + * + * + * @param alertsCount Ver.: always + * @param alertStructures Ver.: always + */ +bool emberAfApplianceEventsAndAlertClusterAlertsNotificationCallback(uint8_t alertsCount, uint8_t * alertStructures); +/** @brief Appliance Events and Alert Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Appliance Events and Alert Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Appliance Events and Alert Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientInitCallback(uint8_t endpoint); +/** @brief Appliance Events and Alert Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Events and Alert Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Appliance Events and Alert Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceEventsAndAlertClusterClientPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Appliance Events and Alert Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterClientTickCallback(uint8_t endpoint); +/** @brief Appliance Events and Alert Cluster Events Notification + * + * + * + * @param eventHeader Ver.: always + * @param eventId Ver.: always + */ +bool emberAfApplianceEventsAndAlertClusterEventsNotificationCallback(uint8_t eventHeader, uint8_t eventId); +/** @brief Appliance Events and Alert Cluster Get Alerts + * + * + * + */ +bool emberAfApplianceEventsAndAlertClusterGetAlertsCallback(void); +/** @brief Appliance Events and Alert Cluster Get Alerts Response + * + * + * + * @param alertsCount Ver.: always + * @param alertStructures Ver.: always + */ +bool emberAfApplianceEventsAndAlertClusterGetAlertsResponseCallback(uint8_t alertsCount, uint8_t * alertStructures); +/** @brief Appliance Events and Alert Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Appliance Events and Alert Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Appliance Events and Alert Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerInitCallback(uint8_t endpoint); +/** @brief Appliance Events and Alert Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Events and Alert Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Appliance Events and Alert Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceEventsAndAlertClusterServerPreAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, + uint8_t size, uint8_t * value); +/** @brief Appliance Events and Alert Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceEventsAndAlertClusterServerTickCallback(uint8_t endpoint); + +/** @} END Appliance Events and Alert Cluster Callbacks */ + +/** @name Appliance Statistics Cluster Callbacks */ +// @{ + +/** @brief Appliance Statistics Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceStatisticsClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Appliance Statistics Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceStatisticsClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Appliance Statistics Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceStatisticsClusterClientInitCallback(uint8_t endpoint); +/** @brief Appliance Statistics Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceStatisticsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Statistics Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceStatisticsClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Appliance Statistics Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceStatisticsClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Appliance Statistics Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceStatisticsClusterClientTickCallback(uint8_t endpoint); +/** @brief Appliance Statistics Cluster Log Notification + * + * + * + * @param timeStamp Ver.: always + * @param logId Ver.: always + * @param logLength Ver.: always + * @param logPayload Ver.: always + */ +bool emberAfApplianceStatisticsClusterLogNotificationCallback(uint32_t timeStamp, uint32_t logId, uint32_t logLength, + uint8_t * logPayload); +/** @brief Appliance Statistics Cluster Log Queue Request + * + * + * + */ +bool emberAfApplianceStatisticsClusterLogQueueRequestCallback(void); +/** @brief Appliance Statistics Cluster Log Queue Response + * + * + * + * @param logQueueSize Ver.: always + * @param logIds Ver.: always + */ +bool emberAfApplianceStatisticsClusterLogQueueResponseCallback(uint8_t logQueueSize, uint8_t * logIds); +/** @brief Appliance Statistics Cluster Log Request + * + * + * + * @param logId Ver.: always + */ +bool emberAfApplianceStatisticsClusterLogRequestCallback(uint32_t logId); +/** @brief Appliance Statistics Cluster Log Response + * + * + * + * @param timeStamp Ver.: always + * @param logId Ver.: always + * @param logLength Ver.: always + * @param logPayload Ver.: always + */ +bool emberAfApplianceStatisticsClusterLogResponseCallback(uint32_t timeStamp, uint32_t logId, uint32_t logLength, + uint8_t * logPayload); +/** @brief Appliance Statistics Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfApplianceStatisticsClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Appliance Statistics Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfApplianceStatisticsClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Appliance Statistics Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfApplianceStatisticsClusterServerInitCallback(uint8_t endpoint); +/** @brief Appliance Statistics Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfApplianceStatisticsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Appliance Statistics Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfApplianceStatisticsClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Appliance Statistics Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfApplianceStatisticsClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Appliance Statistics Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfApplianceStatisticsClusterServerTickCallback(uint8_t endpoint); +/** @brief Appliance Statistics Cluster Statistics Available + * + * + * + * @param logQueueSize Ver.: always + * @param logIds Ver.: always + */ +bool emberAfApplianceStatisticsClusterStatisticsAvailableCallback(uint8_t logQueueSize, uint8_t * logIds); + +/** @} END Appliance Statistics Cluster Callbacks */ + +/** @name Electrical Measurement Cluster Callbacks */ +// @{ + +/** @brief Electrical Measurement Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfElectricalMeasurementClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Electrical Measurement Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfElectricalMeasurementClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Electrical Measurement Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfElectricalMeasurementClusterClientInitCallback(uint8_t endpoint); +/** @brief Electrical Measurement Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfElectricalMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Electrical Measurement Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfElectricalMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Electrical Measurement Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfElectricalMeasurementClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Electrical Measurement Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfElectricalMeasurementClusterClientTickCallback(uint8_t endpoint); +/** @brief Electrical Measurement Cluster Get Measurement Profile Command + * + * + * + * @param attributeId Ver.: always + * @param startTime Ver.: always + * @param numberOfIntervals Ver.: always + */ +bool emberAfElectricalMeasurementClusterGetMeasurementProfileCommandCallback(uint16_t attributeId, uint32_t startTime, + uint8_t numberOfIntervals); +/** @brief Electrical Measurement Cluster Get Measurement Profile Response Command + * + * + * + * @param startTime Ver.: always + * @param status Ver.: always + * @param profileIntervalPeriod Ver.: always + * @param numberOfIntervalsDelivered Ver.: always + * @param attributeId Ver.: always + * @param intervals Ver.: always + */ +bool emberAfElectricalMeasurementClusterGetMeasurementProfileResponseCommandCallback(uint32_t startTime, uint8_t status, + uint8_t profileIntervalPeriod, + uint8_t numberOfIntervalsDelivered, + uint16_t attributeId, uint8_t * intervals); +/** @brief Electrical Measurement Cluster Get Profile Info Command + * + * + * + */ +bool emberAfElectricalMeasurementClusterGetProfileInfoCommandCallback(void); +/** @brief Electrical Measurement Cluster Get Profile Info Response Command + * + * + * + * @param profileCount Ver.: always + * @param profileIntervalPeriod Ver.: always + * @param maxNumberOfIntervals Ver.: always + * @param listOfAttributes Ver.: always + */ +bool emberAfElectricalMeasurementClusterGetProfileInfoResponseCommandCallback(uint8_t profileCount, uint8_t profileIntervalPeriod, + uint8_t maxNumberOfIntervals, + uint8_t * listOfAttributes); +/** @brief Electrical Measurement Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfElectricalMeasurementClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Electrical Measurement Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfElectricalMeasurementClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Electrical Measurement Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfElectricalMeasurementClusterServerInitCallback(uint8_t endpoint); +/** @brief Electrical Measurement Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfElectricalMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Electrical Measurement Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfElectricalMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Electrical Measurement Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfElectricalMeasurementClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Electrical Measurement Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfElectricalMeasurementClusterServerTickCallback(uint8_t endpoint); + +/** @} END Electrical Measurement Cluster Callbacks */ + +/** @name Diagnostics Cluster Callbacks */ +// @{ + +/** @brief Diagnostics Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDiagnosticsClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Diagnostics Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDiagnosticsClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Diagnostics Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDiagnosticsClusterClientInitCallback(uint8_t endpoint); +/** @brief Diagnostics Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDiagnosticsClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Diagnostics Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDiagnosticsClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Diagnostics Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDiagnosticsClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Diagnostics Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDiagnosticsClusterClientTickCallback(uint8_t endpoint); +/** @brief Diagnostics Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfDiagnosticsClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Diagnostics Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfDiagnosticsClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Diagnostics Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfDiagnosticsClusterServerInitCallback(uint8_t endpoint); +/** @brief Diagnostics Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Diagnostics Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfDiagnosticsClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Diagnostics Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfDiagnosticsClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Diagnostics Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfDiagnosticsClusterServerTickCallback(uint8_t endpoint); + +/** @} END Diagnostics Cluster Callbacks */ + +/** @name ZLL Commissioning Cluster Callbacks */ +// @{ + +/** @brief ZLL Commissioning Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfZllCommissioningClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief ZLL Commissioning Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfZllCommissioningClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief ZLL Commissioning Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfZllCommissioningClusterClientInitCallback(uint8_t endpoint); +/** @brief ZLL Commissioning Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfZllCommissioningClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief ZLL Commissioning Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfZllCommissioningClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief ZLL Commissioning Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfZllCommissioningClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief ZLL Commissioning Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfZllCommissioningClusterClientTickCallback(uint8_t endpoint); +/** @brief ZLL Commissioning Cluster Device Information Request + * + * + * + * @param transaction Ver.: always + * @param startIndex Ver.: always + */ +bool emberAfZllCommissioningClusterDeviceInformationRequestCallback(uint32_t transaction, uint8_t startIndex); +/** @brief ZLL Commissioning Cluster Device Information Response + * + * + * + * @param transaction Ver.: always + * @param numberOfSubDevices Ver.: always + * @param startIndex Ver.: always + * @param deviceInformationRecordCount Ver.: always + * @param deviceInformationRecordList Ver.: always + */ +bool emberAfZllCommissioningClusterDeviceInformationResponseCallback(uint32_t transaction, uint8_t numberOfSubDevices, + uint8_t startIndex, uint8_t deviceInformationRecordCount, + uint8_t * deviceInformationRecordList); +/** @brief ZLL Commissioning Cluster Endpoint Information + * + * + * + * @param ieeeAddress Ver.: always + * @param networkAddress Ver.: always + * @param endpointId Ver.: always + * @param profileId Ver.: always + * @param deviceId Ver.: always + * @param version Ver.: always + */ +bool emberAfZllCommissioningClusterEndpointInformationCallback(uint8_t * ieeeAddress, uint16_t networkAddress, uint8_t endpointId, + uint16_t profileId, uint16_t deviceId, uint8_t version); +/** @brief ZLL Commissioning Cluster Get Endpoint List Request + * + * + * + * @param startIndex Ver.: always + */ +bool emberAfZllCommissioningClusterGetEndpointListRequestCallback(uint8_t startIndex); +/** @brief ZLL Commissioning Cluster Get Endpoint List Response + * + * + * + * @param total Ver.: always + * @param startIndex Ver.: always + * @param count Ver.: always + * @param endpointInformationRecordList Ver.: always + */ +bool emberAfZllCommissioningClusterGetEndpointListResponseCallback(uint8_t total, uint8_t startIndex, uint8_t count, + uint8_t * endpointInformationRecordList); +/** @brief ZLL Commissioning Cluster Get Group Identifiers Request + * + * + * + * @param startIndex Ver.: always + */ +bool emberAfZllCommissioningClusterGetGroupIdentifiersRequestCallback(uint8_t startIndex); +/** @brief ZLL Commissioning Cluster Get Group Identifiers Response + * + * + * + * @param total Ver.: always + * @param startIndex Ver.: always + * @param count Ver.: always + * @param groupInformationRecordList Ver.: always + */ +bool emberAfZllCommissioningClusterGetGroupIdentifiersResponseCallback(uint8_t total, uint8_t startIndex, uint8_t count, + uint8_t * groupInformationRecordList); +/** @brief ZLL Commissioning Cluster Identify Request + * + * + * + * @param transaction Ver.: always + * @param identifyDuration Ver.: always + */ +bool emberAfZllCommissioningClusterIdentifyRequestCallback(uint32_t transaction, uint16_t identifyDuration); +/** @brief ZLL Commissioning Cluster Network Join End Device Request + * + * + * + * @param transaction Ver.: always + * @param extendedPanId Ver.: always + * @param keyIndex Ver.: always + * @param encryptedNetworkKey Ver.: always + * @param networkUpdateId Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + * @param networkAddress Ver.: always + * @param groupIdentifiersBegin Ver.: always + * @param groupIdentifiersEnd Ver.: always + * @param freeNetworkAddressRangeBegin Ver.: always + * @param freeNetworkAddressRangeEnd Ver.: always + * @param freeGroupIdentifierRangeBegin Ver.: always + * @param freeGroupIdentifierRangeEnd Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkJoinEndDeviceRequestCallback( + uint32_t transaction, uint8_t * extendedPanId, uint8_t keyIndex, uint8_t * encryptedNetworkKey, uint8_t networkUpdateId, + uint8_t logicalChannel, uint16_t panId, uint16_t networkAddress, uint16_t groupIdentifiersBegin, uint16_t groupIdentifiersEnd, + uint16_t freeNetworkAddressRangeBegin, uint16_t freeNetworkAddressRangeEnd, uint16_t freeGroupIdentifierRangeBegin, + uint16_t freeGroupIdentifierRangeEnd); +/** @brief ZLL Commissioning Cluster Network Join End Device Response + * + * + * + * @param transaction Ver.: always + * @param status Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkJoinEndDeviceResponseCallback(uint32_t transaction, uint8_t status); +/** @brief ZLL Commissioning Cluster Network Join Router Request + * + * + * + * @param transaction Ver.: always + * @param extendedPanId Ver.: always + * @param keyIndex Ver.: always + * @param encryptedNetworkKey Ver.: always + * @param networkUpdateId Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + * @param networkAddress Ver.: always + * @param groupIdentifiersBegin Ver.: always + * @param groupIdentifiersEnd Ver.: always + * @param freeNetworkAddressRangeBegin Ver.: always + * @param freeNetworkAddressRangeEnd Ver.: always + * @param freeGroupIdentifierRangeBegin Ver.: always + * @param freeGroupIdentifierRangeEnd Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkJoinRouterRequestCallback( + uint32_t transaction, uint8_t * extendedPanId, uint8_t keyIndex, uint8_t * encryptedNetworkKey, uint8_t networkUpdateId, + uint8_t logicalChannel, uint16_t panId, uint16_t networkAddress, uint16_t groupIdentifiersBegin, uint16_t groupIdentifiersEnd, + uint16_t freeNetworkAddressRangeBegin, uint16_t freeNetworkAddressRangeEnd, uint16_t freeGroupIdentifierRangeBegin, + uint16_t freeGroupIdentifierRangeEnd); +/** @brief ZLL Commissioning Cluster Network Join Router Response + * + * + * + * @param transaction Ver.: always + * @param status Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkJoinRouterResponseCallback(uint32_t transaction, uint8_t status); +/** @brief ZLL Commissioning Cluster Network Start Request + * + * + * + * @param transaction Ver.: always + * @param extendedPanId Ver.: always + * @param keyIndex Ver.: always + * @param encryptedNetworkKey Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + * @param networkAddress Ver.: always + * @param groupIdentifiersBegin Ver.: always + * @param groupIdentifiersEnd Ver.: always + * @param freeNetworkAddressRangeBegin Ver.: always + * @param freeNetworkAddressRangeEnd Ver.: always + * @param freeGroupIdentifierRangeBegin Ver.: always + * @param freeGroupIdentifierRangeEnd Ver.: always + * @param initiatorIeeeAddress Ver.: always + * @param initiatorNetworkAddress Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkStartRequestCallback( + uint32_t transaction, uint8_t * extendedPanId, uint8_t keyIndex, uint8_t * encryptedNetworkKey, uint8_t logicalChannel, + uint16_t panId, uint16_t networkAddress, uint16_t groupIdentifiersBegin, uint16_t groupIdentifiersEnd, + uint16_t freeNetworkAddressRangeBegin, uint16_t freeNetworkAddressRangeEnd, uint16_t freeGroupIdentifierRangeBegin, + uint16_t freeGroupIdentifierRangeEnd, uint8_t * initiatorIeeeAddress, uint16_t initiatorNetworkAddress); +/** @brief ZLL Commissioning Cluster Network Start Response + * + * + * + * @param transaction Ver.: always + * @param status Ver.: always + * @param extendedPanId Ver.: always + * @param networkUpdateId Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkStartResponseCallback(uint32_t transaction, uint8_t status, uint8_t * extendedPanId, + uint8_t networkUpdateId, uint8_t logicalChannel, uint16_t panId); +/** @brief ZLL Commissioning Cluster Network Update Request + * + * + * + * @param transaction Ver.: always + * @param extendedPanId Ver.: always + * @param networkUpdateId Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + * @param networkAddress Ver.: always + */ +bool emberAfZllCommissioningClusterNetworkUpdateRequestCallback(uint32_t transaction, uint8_t * extendedPanId, + uint8_t networkUpdateId, uint8_t logicalChannel, uint16_t panId, + uint16_t networkAddress); +/** @brief ZLL Commissioning Cluster Reset To Factory New Request + * + * + * + * @param transaction Ver.: always + */ +bool emberAfZllCommissioningClusterResetToFactoryNewRequestCallback(uint32_t transaction); +/** @brief ZLL Commissioning Cluster Scan Request + * + * + * + * @param transaction Ver.: always + * @param zigbeeInformation Ver.: always + * @param zllInformation Ver.: always + */ +bool emberAfZllCommissioningClusterScanRequestCallback(uint32_t transaction, uint8_t zigbeeInformation, uint8_t zllInformation); +/** @brief ZLL Commissioning Cluster Scan Response + * + * + * + * @param transaction Ver.: always + * @param rssiCorrection Ver.: always + * @param zigbeeInformation Ver.: always + * @param zllInformation Ver.: always + * @param keyBitmask Ver.: always + * @param responseId Ver.: always + * @param extendedPanId Ver.: always + * @param networkUpdateId Ver.: always + * @param logicalChannel Ver.: always + * @param panId Ver.: always + * @param networkAddress Ver.: always + * @param numberOfSubDevices Ver.: always + * @param totalGroupIds Ver.: always + * @param endpointId Ver.: always + * @param profileId Ver.: always + * @param deviceId Ver.: always + * @param version Ver.: always + * @param groupIdCount Ver.: always + */ +bool emberAfZllCommissioningClusterScanResponseCallback(uint32_t transaction, uint8_t rssiCorrection, uint8_t zigbeeInformation, + uint8_t zllInformation, uint16_t keyBitmask, uint32_t responseId, + uint8_t * extendedPanId, uint8_t networkUpdateId, uint8_t logicalChannel, + uint16_t panId, uint16_t networkAddress, uint8_t numberOfSubDevices, + uint8_t totalGroupIds, uint8_t endpointId, uint16_t profileId, + uint16_t deviceId, uint8_t version, uint8_t groupIdCount); +/** @brief ZLL Commissioning Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfZllCommissioningClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief ZLL Commissioning Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfZllCommissioningClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief ZLL Commissioning Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfZllCommissioningClusterServerInitCallback(uint8_t endpoint); +/** @brief ZLL Commissioning Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfZllCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief ZLL Commissioning Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfZllCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief ZLL Commissioning Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfZllCommissioningClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief ZLL Commissioning Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfZllCommissioningClusterServerTickCallback(uint8_t endpoint); + +/** @} END ZLL Commissioning Cluster Callbacks */ + +/** @name Sample Mfg Specific Cluster Cluster Callbacks */ +// @{ + +/** @brief Sample Mfg Specific Cluster Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Sample Mfg Specific Cluster Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Sample Mfg Specific Cluster Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientInitCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sample Mfg Specific Cluster Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Sample Mfg Specific Cluster Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSampleMfgSpecificClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Sample Mfg Specific Cluster Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSampleMfgSpecificClusterClientTickCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster Cluster Command One + * + * + * + * @param argOne Ver.: always + */ +bool emberAfSampleMfgSpecificClusterCommandOneCallback(uint8_t argOne); +/** @brief Sample Mfg Specific Cluster Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Sample Mfg Specific Cluster Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Sample Mfg Specific Cluster Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerInitCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sample Mfg Specific Cluster Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Sample Mfg Specific Cluster Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSampleMfgSpecificClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Sample Mfg Specific Cluster Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSampleMfgSpecificClusterServerTickCallback(uint8_t endpoint); + +/** @} END Sample Mfg Specific Cluster Cluster Callbacks */ + +/** @name Sample Mfg Specific Cluster 2 Cluster Callbacks */ +// @{ + +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientInitCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSampleMfgSpecificCluster2ClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Sample Mfg Specific Cluster 2 Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ClientTickCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster 2 Cluster Command Two + * + * + * + * @param argOne Ver.: always + */ +bool emberAfSampleMfgSpecificCluster2CommandTwoCallback(uint8_t argOne); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerInitCallback(uint8_t endpoint); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSampleMfgSpecificCluster2ServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Sample Mfg Specific Cluster 2 Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSampleMfgSpecificCluster2ServerTickCallback(uint8_t endpoint); + +/** @} END Sample Mfg Specific Cluster 2 Cluster Callbacks */ + +/** @name Configuration Cluster Cluster Callbacks */ +// @{ + +/** @brief Configuration Cluster Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOtaConfigurationClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Configuration Cluster Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOtaConfigurationClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Configuration Cluster Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOtaConfigurationClusterClientInitCallback(uint8_t endpoint); +/** @brief Configuration Cluster Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOtaConfigurationClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Configuration Cluster Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOtaConfigurationClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Configuration Cluster Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOtaConfigurationClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Configuration Cluster Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOtaConfigurationClusterClientTickCallback(uint8_t endpoint); +/** @brief Configuration Cluster Cluster Lock Tokens + * + * + * + */ +bool emberAfOtaConfigurationClusterLockTokensCallback(void); +/** @brief Configuration Cluster Cluster Read Tokens + * + * + * + * @param token Ver.: always + */ +bool emberAfOtaConfigurationClusterReadTokensCallback(uint16_t token); +/** @brief Configuration Cluster Cluster Return Token + * + * + * + * @param token Ver.: always + * @param data Ver.: always + */ +bool emberAfOtaConfigurationClusterReturnTokenCallback(uint16_t token, uint8_t * data); +/** @brief Configuration Cluster Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfOtaConfigurationClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief Configuration Cluster Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfOtaConfigurationClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief Configuration Cluster Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfOtaConfigurationClusterServerInitCallback(uint8_t endpoint); +/** @brief Configuration Cluster Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfOtaConfigurationClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, + EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief Configuration Cluster Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfOtaConfigurationClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief Configuration Cluster Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfOtaConfigurationClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief Configuration Cluster Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfOtaConfigurationClusterServerTickCallback(uint8_t endpoint); +/** @brief Configuration Cluster Cluster Set Token + * + * + * + * @param token Ver.: always + * @param data Ver.: always + */ +bool emberAfOtaConfigurationClusterSetTokenCallback(uint16_t token, uint8_t * data); +/** @brief Configuration Cluster Cluster Unlock Tokens + * + * + * + * @param data Ver.: always + */ +bool emberAfOtaConfigurationClusterUnlockTokensCallback(uint8_t * data); + +/** @} END Configuration Cluster Cluster Callbacks */ + +/** @name MFGLIB Cluster Cluster Callbacks */ +// @{ + +/** @brief MFGLIB Cluster Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMfglibClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief MFGLIB Cluster Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMfglibClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief MFGLIB Cluster Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMfglibClusterClientInitCallback(uint8_t endpoint); +/** @brief MFGLIB Cluster Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMfglibClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief MFGLIB Cluster Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMfglibClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief MFGLIB Cluster Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMfglibClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief MFGLIB Cluster Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMfglibClusterClientTickCallback(uint8_t endpoint); +/** @brief MFGLIB Cluster Cluster Rx Mode + * + * + * + * @param channel Ver.: always + * @param power Ver.: always + * @param time Ver.: always + */ +bool emberAfMfglibClusterRxModeCallback(uint8_t channel, int8_t power, uint16_t time); +/** @brief MFGLIB Cluster Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfMfglibClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief MFGLIB Cluster Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfMfglibClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief MFGLIB Cluster Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfMfglibClusterServerInitCallback(uint8_t endpoint); +/** @brief MFGLIB Cluster Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfMfglibClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief MFGLIB Cluster Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfMfglibClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief MFGLIB Cluster Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfMfglibClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief MFGLIB Cluster Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfMfglibClusterServerTickCallback(uint8_t endpoint); +/** @brief MFGLIB Cluster Cluster Stream + * + * + * + * @param channel Ver.: always + * @param power Ver.: always + * @param time Ver.: always + */ +bool emberAfMfglibClusterStreamCallback(uint8_t channel, int8_t power, uint16_t time); +/** @brief MFGLIB Cluster Cluster Tone + * + * + * + * @param channel Ver.: always + * @param power Ver.: always + * @param time Ver.: always + */ +bool emberAfMfglibClusterToneCallback(uint8_t channel, int8_t power, uint16_t time); + +/** @} END MFGLIB Cluster Cluster Callbacks */ + +/** @name SL Works With All Hubs Cluster Callbacks */ +// @{ + +/** @brief SL Works With All Hubs Cluster Aps Ack Enablement Query Response + * + * + * + * @param numberExemptClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterApsAckEnablementQueryResponseCallback(uint8_t numberExemptClusters, uint8_t * clusterId); +/** @brief SL Works With All Hubs Cluster Aps Ack Requirement Query + * + * + * + */ +bool emberAfSlWwahClusterApsAckRequirementQueryCallback(void); +/** @brief SL Works With All Hubs Cluster Aps Link Key Authorization Query + * + * + * + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterApsLinkKeyAuthorizationQueryCallback(uint16_t clusterId); +/** @brief SL Works With All Hubs Cluster Aps Link Key Authorization Query Response + * + * + * + * @param clusterId Ver.: always + * @param apsLinkKeyAuthStatus Ver.: always + */ +bool emberAfSlWwahClusterApsLinkKeyAuthorizationQueryResponseCallback(uint16_t clusterId, uint8_t apsLinkKeyAuthStatus); +/** @brief SL Works With All Hubs Cluster Clear Binding Table + * + * + * + */ +bool emberAfSlWwahClusterClearBindingTableCallback(void); +/** @brief SL Works With All Hubs Cluster Client Attribute Changed + * + * Client Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSlWwahClusterClientAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief SL Works With All Hubs Cluster Client Default Response + * + * This function is called when the client receives the default response from + * the server. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSlWwahClusterClientDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief SL Works With All Hubs Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSlWwahClusterClientInitCallback(uint8_t endpoint); +/** @brief SL Works With All Hubs Cluster Client Manufacturer Specific Attribute Changed + * + * Client Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSlWwahClusterClientManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief SL Works With All Hubs Cluster Client Message Sent + * + * Client Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSlWwahClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief SL Works With All Hubs Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSlWwahClusterClientPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief SL Works With All Hubs Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSlWwahClusterClientTickCallback(uint8_t endpoint); +/** @brief SL Works With All Hubs Cluster Debug Report Query + * + * + * + * @param debugReportId Ver.: always + */ +bool emberAfSlWwahClusterDebugReportQueryCallback(uint8_t debugReportId); +/** @brief SL Works With All Hubs Cluster Debug Report Query Response + * + * + * + * @param debugReportId Ver.: always + * @param debugReportData Ver.: always + */ +bool emberAfSlWwahClusterDebugReportQueryResponseCallback(uint8_t debugReportId, uint8_t * debugReportData); +/** @brief SL Works With All Hubs Cluster Disable Aps Link Key Authorization + * + * + * + * @param numberExemptClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterDisableApsLinkKeyAuthorizationCallback(uint8_t numberExemptClusters, uint8_t * clusterId); +/** @brief SL Works With All Hubs Cluster Disable Configuration Mode + * + * + * + */ +bool emberAfSlWwahClusterDisableConfigurationModeCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Mgmt Leave Without Rejoin + * + * + * + */ +bool emberAfSlWwahClusterDisableMgmtLeaveWithoutRejoinCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Ota Downgrades + * + * + * + */ +bool emberAfSlWwahClusterDisableOtaDowngradesCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Periodic Router Check Ins + * + * + * + */ +bool emberAfSlWwahClusterDisablePeriodicRouterCheckInsCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Touchlink Interpan Message Support + * + * + * + */ +bool emberAfSlWwahClusterDisableTouchlinkInterpanMessageSupportCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Wwah App Event Retry Algorithm + * + * + * + */ +bool emberAfSlWwahClusterDisableWwahAppEventRetryAlgorithmCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Wwah Bad Parent Recovery + * + * + * + */ +bool emberAfSlWwahClusterDisableWwahBadParentRecoveryCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Wwah Parent Classification + * + * + * + */ +bool emberAfSlWwahClusterDisableWwahParentClassificationCallback(void); +/** @brief SL Works With All Hubs Cluster Disable Wwah Rejoin Algorithm + * + * + * + */ +bool emberAfSlWwahClusterDisableWwahRejoinAlgorithmCallback(void); +/** @brief SL Works With All Hubs Cluster Enable Aps Link Key Authorization + * + * + * + * @param numberExemptClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterEnableApsLinkKeyAuthorizationCallback(uint8_t numberExemptClusters, uint8_t * clusterId); +/** @brief SL Works With All Hubs Cluster Enable Configuration Mode + * + * + * + */ +bool emberAfSlWwahClusterEnableConfigurationModeCallback(void); +/** @brief SL Works With All Hubs Cluster Enable Periodic Router Check Ins + * + * + * + * @param checkInInterval Ver.: always + */ +bool emberAfSlWwahClusterEnablePeriodicRouterCheckInsCallback(uint16_t checkInInterval); +/** @brief SL Works With All Hubs Cluster Enable Tc Security On Ntwk Key Rotation + * + * + * + */ +bool emberAfSlWwahClusterEnableTcSecurityOnNtwkKeyRotationCallback(void); +/** @brief SL Works With All Hubs Cluster Enable Wwah App Event Retry Algorithm + * + * + * + * @param firstBackoffTimeSeconds Ver.: always + * @param backoffSeqCommonRatio Ver.: always + * @param maxBackoffTimeSeconds Ver.: always + * @param maxRedeliveryAttempts Ver.: always + */ +bool emberAfSlWwahClusterEnableWwahAppEventRetryAlgorithmCallback(uint8_t firstBackoffTimeSeconds, uint8_t backoffSeqCommonRatio, + uint32_t maxBackoffTimeSeconds, uint8_t maxRedeliveryAttempts); +/** @brief SL Works With All Hubs Cluster Enable Wwah Bad Parent Recovery + * + * + * + */ +bool emberAfSlWwahClusterEnableWwahBadParentRecoveryCallback(void); +/** @brief SL Works With All Hubs Cluster Enable Wwah Parent Classification + * + * + * + */ +bool emberAfSlWwahClusterEnableWwahParentClassificationCallback(void); +/** @brief SL Works With All Hubs Cluster Enable Wwah Rejoin Algorithm + * + * + * + * @param fastRejoinTimeoutSeconds Ver.: always + * @param durationBetweenRejoinsSeconds Ver.: always + * @param fastRejoinFirstBackoffSeconds Ver.: always + * @param maxBackoffTimeSeconds Ver.: always + * @param maxBackoffIterations Ver.: always + */ +bool emberAfSlWwahClusterEnableWwahRejoinAlgorithmCallback(uint16_t fastRejoinTimeoutSeconds, + uint16_t durationBetweenRejoinsSeconds, + uint16_t fastRejoinFirstBackoffSeconds, uint16_t maxBackoffTimeSeconds, + uint16_t maxBackoffIterations); +/** @brief SL Works With All Hubs Cluster New Debug Report Notification + * + * + * + * @param debugReportId Ver.: always + * @param debugReportSize Ver.: always + */ +bool emberAfSlWwahClusterNewDebugReportNotificationCallback(uint8_t debugReportId, uint32_t debugReportSize); +/** @brief SL Works With All Hubs Cluster Power Descriptor Change + * + * + * + * @param currentPowerMode Ver.: always + * @param availablePowerSources Ver.: always + * @param currentPowerSource Ver.: always + * @param currentPowerSourceLevel Ver.: always + */ +bool emberAfSlWwahClusterPowerDescriptorChangeCallback(uint32_t currentPowerMode, uint32_t availablePowerSources, + uint32_t currentPowerSource, uint32_t currentPowerSourceLevel); +/** @brief SL Works With All Hubs Cluster Powering Off Notification + * + * + * + * @param powerNotificationReason Ver.: always + * @param manufacturerId Ver.: always + * @param manufacturerReasonLength Ver.: always + * @param manufacturerReason Ver.: always + */ +bool emberAfSlWwahClusterPoweringOffNotificationCallback(uint8_t powerNotificationReason, uint16_t manufacturerId, + uint8_t manufacturerReasonLength, uint8_t * manufacturerReason); +/** @brief SL Works With All Hubs Cluster Powering On Notification + * + * + * + * @param powerNotificationReason Ver.: always + * @param manufacturerId Ver.: always + * @param manufacturerReasonLength Ver.: always + * @param manufacturerReason Ver.: always + */ +bool emberAfSlWwahClusterPoweringOnNotificationCallback(uint8_t powerNotificationReason, uint16_t manufacturerId, + uint8_t manufacturerReasonLength, uint8_t * manufacturerReason); +/** @brief SL Works With All Hubs Cluster Remove Aps Acks On Unicasts Requirement + * + * + * + */ +bool emberAfSlWwahClusterRemoveApsAcksOnUnicastsRequirementCallback(void); +/** @brief SL Works With All Hubs Cluster Request New Aps Link Key + * + * + * + */ +bool emberAfSlWwahClusterRequestNewApsLinkKeyCallback(void); +/** @brief SL Works With All Hubs Cluster Request Time + * + * + * + */ +bool emberAfSlWwahClusterRequestTimeCallback(void); +/** @brief SL Works With All Hubs Cluster Require Aps Acks On Unicasts + * + * + * + * @param numberExemptClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterRequireApsAcksOnUnicastsCallback(uint8_t numberExemptClusters, uint8_t * clusterId); +/** @brief SL Works With All Hubs Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + */ +void emberAfSlWwahClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId); +/** @brief SL Works With All Hubs Cluster Server Default Response + * + * This function is called when the server receives the default response from + * the client. + * + * @param endpoint Destination endpoint Ver.: always + * @param commandId Command id Ver.: always + * @param status Status in default response Ver.: always + */ +void emberAfSlWwahClusterServerDefaultResponseCallback(uint8_t endpoint, uint8_t commandId, EmberAfStatus status); +/** @brief SL Works With All Hubs Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized Ver.: always + */ +void emberAfSlWwahClusterServerInitCallback(uint8_t endpoint); +/** @brief SL Works With All Hubs Cluster Server Manufacturer Specific Attribute Changed + * + * Server Manufacturer Specific Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute that changed Ver.: always + * @param manufacturerCode Manufacturer Code of the attribute that changed + * Ver.: always + */ +void emberAfSlWwahClusterServerManufacturerSpecificAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + uint16_t manufacturerCode); +/** @brief SL Works With All Hubs Cluster Server Message Sent + * + * Server Message Sent + * + * @param type The type of message sent Ver.: always + * @param indexOrDestination The destination or address to which the message was + * sent Ver.: always + * @param apsFrame The APS frame for the message Ver.: always + * @param msgLen The length of the message Ver.: always + * @param message The message that was sent Ver.: always + * @param status The status of the sent message Ver.: always + */ +void emberAfSlWwahClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status); +/** @brief SL Works With All Hubs Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param endpoint Endpoint that is being initialized Ver.: always + * @param attributeId Attribute to be changed Ver.: always + * @param attributeType Attribute type Ver.: always + * @param size Attribute size Ver.: always + * @param value Attribute value Ver.: always + */ +EmberAfStatus emberAfSlWwahClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value); +/** @brief SL Works With All Hubs Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served Ver.: always + */ +void emberAfSlWwahClusterServerTickCallback(uint8_t endpoint); +/** @brief SL Works With All Hubs Cluster Set Ias Zone Enrollment Method + * + * + * + * @param enrollmentMode Ver.: always + */ +bool emberAfSlWwahClusterSetIasZoneEnrollmentMethodCallback(uint8_t enrollmentMode); +/** @brief SL Works With All Hubs Cluster Set Mac Poll Failure Wait Time + * + * + * + * @param waitTime Ver.: always + */ +bool emberAfSlWwahClusterSetMacPollFailureWaitTimeCallback(uint8_t waitTime); +/** @brief SL Works With All Hubs Cluster Set Pending Network Update + * + * + * + * @param channel Ver.: always + * @param panId Ver.: always + */ +bool emberAfSlWwahClusterSetPendingNetworkUpdateCallback(uint8_t channel, uint16_t panId); +/** @brief SL Works With All Hubs Cluster Short Address Change + * + * + * + * @param deviceEui64 Ver.: always + * @param deviceShort Ver.: always + */ +bool emberAfSlWwahClusterShortAddressChangeCallback(uint8_t * deviceEui64, uint16_t deviceShort); +/** @brief SL Works With All Hubs Cluster Survey Beacons + * + * + * + * @param standardBeacons Ver.: always + */ +bool emberAfSlWwahClusterSurveyBeaconsCallback(uint8_t standardBeacons); +/** @brief SL Works With All Hubs Cluster Survey Beacons Response + * + * + * + * @param numberOfBeacons Ver.: always + * @param beacon Ver.: always + */ +bool emberAfSlWwahClusterSurveyBeaconsResponseCallback(uint8_t numberOfBeacons, uint8_t * beacon); +/** @brief SL Works With All Hubs Cluster Trust Center For Cluster Server Query + * + * + * + */ +bool emberAfSlWwahClusterTrustCenterForClusterServerQueryCallback(void); +/** @brief SL Works With All Hubs Cluster Trust Center For Cluster Server Query Response + * + * + * + * @param numberOfClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterTrustCenterForClusterServerQueryResponseCallback(uint8_t numberOfClusters, uint8_t * clusterId); +/** @brief SL Works With All Hubs Cluster Use Trust Center For Cluster Server + * + * + * + * @param numberOfClusters Ver.: always + * @param clusterId Ver.: always + */ +bool emberAfSlWwahClusterUseTrustCenterForClusterServerCallback(uint8_t numberOfClusters, uint8_t * clusterId); +/** @brief SL Works With All Hubs Cluster Use Trust Center For Cluster Server Response + * + * + * + * @param status Ver.: always + * @param clusterStatusLength Ver.: always + * @param clusterStatus Ver.: always + */ +bool emberAfSlWwahClusterUseTrustCenterForClusterServerResponseCallback(uint8_t status, uint8_t clusterStatusLength, + uint8_t * clusterStatus); + +/** @} END SL Works With All Hubs Cluster Callbacks */ + +/** @name Temperature Measurement Server Cluster Plugin Callbacks */ +// @{ + +/** @brief Over temperature state changed + * + * This callback is generated when the temperature rises over the assert + * thresholds (warning and critical) or drops below the deassert thresholds + * (warning and critical) + * + * @param previousState, the state prior to the state change + * + * @param newState, the new state of the state change + * + * EMBER_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE_NORMAL : normal state + * EMBER_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE_WARNING : warning state + * EMBER_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE_CRITICAL : critical state + * + * Ver.: always + */ +void emberAfPluginTemperatureMeasurementServerOverTemperatureCallback(uint8_t previousState, uint8_t newState); +/** @} END Temperature Measurement Server Cluster 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(bool enter, SleepModes sleepMode); +/** @} END HAL Library Plugin Callbacks */ + +/** @name Basic Server Cluster Plugin Callbacks */ +// @{ + +/** @brief Reset To Factory Defaults + * + * This function is called by the Basic server plugin when a request to reset + * to factory defaults is received. The plugin will reset attributes managed by + * the framework to their default values. The application should perform any + * other necessary reset-related operations in this callback, including + * resetting any externally-stored attributes. + * + * @param endpoint Ver.: always + */ +void emberAfPluginBasicResetToFactoryDefaultsCallback(uint8_t endpoint); +/** @} END Basic Server Cluster Plugin Callbacks */ + +/** @} END addtogroup */ +#ifdef __cplusplus +} +#endif // #ifdef __cplusplus + +#endif // SILABS_EMBER_AF_CALLBACK_PROTOTYPES diff --git a/examples/temperature-measurement-app/esp32/main/gen/client-command-macro.h b/examples/temperature-measurement-app/esp32/main/gen/client-command-macro.h new file mode 100644 index 00000000000000..f876f73c9fb9f5 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/client-command-macro.h @@ -0,0 +1,8908 @@ +/** + * + * 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. + */ +// 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/temperature-measurement-app/esp32/main/gen/cluster-id.h b/examples/temperature-measurement-app/esp32/main/gen/cluster-id.h new file mode 100644 index 00000000000000..fd7ebfad3366b1 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/cluster-id.h @@ -0,0 +1,155 @@ +/** + * + * 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. + */ +// 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/temperature-measurement-app/esp32/main/gen/clusters-callback-stubs.c b/examples/temperature-measurement-app/esp32/main/gen/clusters-callback-stubs.c new file mode 100644 index 00000000000000..adf75ceeb89c97 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/clusters-callback-stubs.c @@ -0,0 +1,385 @@ +/** + * + * 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. + */ + +// This callback file is created for your convenience. You may add application +// code to this file. If you regenerate this file over a previous version, the +// previous version will be overwritten and any code you have added will be +// lost. + +#include "af.h" + +/** @brief Identify Cluster Identify Query Response + * + * + * + * @param timeout Ver.: always + */ +bool emberAfIdentifyClusterIdentifyQueryResponseCallback(uint16_t timeout) +{ + return false; +} + +/** @brief Door Lock Cluster Clear All Pins + * + * + * + */ +bool emberAfDoorLockClusterClearAllPinsCallback(void) +{ + return false; +} + +/** @brief Door Lock Cluster Clear All Rfids + * + * + * + */ +bool emberAfDoorLockClusterClearAllRfidsCallback(void) +{ + return false; +} + +/** @brief Door Lock Cluster Clear Holiday Schedule + * + * + * + * @param scheduleId Ver.: always + */ +bool emberAfDoorLockClusterClearHolidayScheduleCallback(uint8_t scheduleId) +{ + return false; +} + +/** @brief Door Lock Cluster Clear Pin + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearPinCallback(uint16_t userId) +{ + return false; +} + +/** @brief Door Lock Cluster Clear Rfid + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearRfidCallback(uint16_t userId) +{ + return false; +} + +/** @brief Door Lock Cluster Clear Weekday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId) +{ + return false; +} + +/** @brief Door Lock Cluster Get Holiday Schedule + * + * + * + * @param scheduleId Ver.: always + */ +bool emberAfDoorLockClusterGetHolidayScheduleCallback(uint8_t scheduleId) +{ + return false; +} + +/** @brief Door Lock Cluster Get Log Record + * + * + * + * @param logIndex Ver.: always + */ +bool emberAfDoorLockClusterGetLogRecordCallback(uint16_t logIndex) +{ + return false; +} + +/** @brief Door Lock Cluster Get Pin + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetPinCallback(uint16_t userId) +{ + return false; +} + +/** @brief Door Lock Cluster Get Rfid + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetRfidCallback(uint16_t userId) +{ + return false; +} + +/** @brief Door Lock Cluster Get User Type + * + * + * + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetUserTypeCallback(uint16_t userId) +{ + return false; +} + +/** @brief Door Lock Cluster Get Weekday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId) +{ + return false; +} + +/** @brief Door Lock Cluster Get Yearday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterGetYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId) +{ + return false; +} + +/** @brief Door Lock Cluster Lock Door + * + * + * + * @param PIN Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterLockDoorCallback(uint8_t * PIN) +{ + return false; +} + +/** @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) +{ + return false; +} + +/** @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) +{ + return false; +} + +/** @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) +{ + return false; +} + +/** @brief Door Lock Cluster Clear Yearday Schedule + * + * + * + * @param scheduleId Ver.: always + * @param userId Ver.: always + */ +bool emberAfDoorLockClusterClearYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId) +{ + return false; +} + +/** @brief Door Lock Cluster Set User Type + * + * + * + * @param userId Ver.: always + * @param userType Ver.: always + */ +bool emberAfDoorLockClusterSetUserTypeCallback(uint16_t userId, uint8_t userType) +{ + return false; +} + +/** @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) +{ + return false; +} + +/** @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) +{ + return false; +} + +/** @brief Door Lock Cluster Unlock Door + * + * + * + * @param PIN Ver.: since ha-1.2-05-3520-29 + */ +bool emberAfDoorLockClusterUnlockDoorCallback(uint8_t * PIN) +{ + return false; +} + +/** @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) +{ + return false; +} + +/** @brief IAS Zone Cluster Zone Enroll Request + * + * + * + * @param zoneType Ver.: always + * @param manufacturerCode Ver.: always + */ +bool emberAfIasZoneClusterZoneEnrollRequestCallback(uint16_t zoneType, uint16_t manufacturerCode) +{ + return false; +} + +/** @brief IAS Zone Cluster Zone Enroll Response + * + * + * + * @param enrollResponseCode Ver.: always + * @param zoneId Ver.: always + */ +bool emberAfIasZoneClusterZoneEnrollResponseCallback(uint8_t enrollResponseCode, uint8_t zoneId) +{ + return false; +} + +/** @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) +{ + return false; +} + +// endpoint_config.h callbacks, grep'd from SDK, comment these out as clusters come in + +void emberAfDoorLockClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId) {} +void emberAfIasZoneClusterClientInitCallback(uint8_t endpoint) {} +void emberAfIasZoneClusterServerInitCallback(uint8_t endpoint) {} +void emberAfIasZoneClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint16_t indexOrDestination, + EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, + EmberStatus status) +{} + +EmberAfStatus emberAfIasZoneClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value) +{ + return EMBER_ZCL_STATUS_SUCCESS; +} + +void emberAfPluginDoorLockServerInitCallback(void) {} +void emberAfPollControlClusterServerAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId) {} +void emberAfPollControlClusterServerInitCallback(uint8_t endpoint) {} +void emberAfPluginPollControlServerStackStatusCallback(EmberStatus status) {} +EmberAfStatus emberAfPollControlClusterServerPreAttributeChangedCallback(uint8_t endpoint, EmberAfAttributeId attributeId, + EmberAfAttributeType attributeType, uint8_t size, + uint8_t * value) +{ + return EMBER_ZCL_STATUS_SUCCESS; +} + +void emberAfPluginIasZoneClientZdoCallback(EmberNodeId emberNodeId, EmberApsFrame * apsFrame, uint8_t * message, uint16_t length) {} + +void emberAfPluginIasZoneClientWriteAttributesResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen) {} + +void emberAfPluginIasZoneClientReadAttributesResponseCallback(EmberAfClusterId clusterId, uint8_t * buffer, uint16_t bufLen) {} diff --git a/examples/temperature-measurement-app/esp32/main/gen/command-id.h b/examples/temperature-measurement-app/esp32/main/gen/command-id.h new file mode 100644 index 00000000000000..e56b090b9108d2 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/command-id.h @@ -0,0 +1,1020 @@ +/** + * + * 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. + */ +// 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/temperature-measurement-app/esp32/main/gen/debug-printing-test.h b/examples/temperature-measurement-app/esp32/main/gen/debug-printing-test.h new file mode 100644 index 00000000000000..6c5b31fa1d5a0a --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/debug-printing-test.h @@ -0,0 +1,191 @@ +/** + * + * 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. + */ +// This file is generated by Simplicity Studio. Please do not edit manually. +// +// + +// This is the test header, that enables all printing +// Enclosing macro to prevent multiple inclusion +#ifndef SILABS_EMBER_AF_PRINTING_TEST +#define SILABS_EMBER_AF_PRINTING_TEST + +#define EMBER_AF_PRINT_ENABLE +#define EMBER_AF_PRINT_BASIC_CLUSTER 0x0001 +#define EMBER_AF_PRINT_POWER_CONFIG_CLUSTER 0x0002 +#define EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER 0x0004 +#define EMBER_AF_PRINT_IDENTIFY_CLUSTER 0x0008 +#define EMBER_AF_PRINT_GROUPS_CLUSTER 0x0010 +#define EMBER_AF_PRINT_SCENES_CLUSTER 0x0020 +#define EMBER_AF_PRINT_ON_OFF_CLUSTER 0x0040 +#define EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER 0x0080 +#define EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER 0x0101 +#define EMBER_AF_PRINT_ALARM_CLUSTER 0x0102 +#define EMBER_AF_PRINT_TIME_CLUSTER 0x0104 +#define EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER 0x0108 +#define EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER 0x0110 +#define EMBER_AF_PRINT_COMMISSIONING_CLUSTER 0x0120 +#define EMBER_AF_PRINT_PARTITION_CLUSTER 0x0140 +#define EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER 0x0180 +#define EMBER_AF_PRINT_POWER_PROFILE_CLUSTER 0x0201 +#define EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER 0x0202 +#define EMBER_AF_PRINT_POLL_CONTROL_CLUSTER 0x0204 +#define EMBER_AF_PRINT_GREEN_POWER_CLUSTER 0x0208 +#define EMBER_AF_PRINT_KEEPALIVE_CLUSTER 0x0210 +#define EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER 0x0220 +#define EMBER_AF_PRINT_DOOR_LOCK_CLUSTER 0x0240 +#define EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER 0x0280 +#define EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER 0x0301 +#define EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER 0x0302 +#define EMBER_AF_PRINT_THERMOSTAT_CLUSTER 0x0304 +#define EMBER_AF_PRINT_FAN_CONTROL_CLUSTER 0x0308 +#define EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER 0x0310 +#define EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER 0x0320 +#define EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER 0x0340 +#define EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER 0x0380 +#define EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER 0x0401 +#define EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER 0x0402 +#define EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER 0x0404 +#define EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER 0x0408 +#define EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER 0x0410 +#define EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER 0x0420 +#define EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER 0x0440 +#define EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0480 +#define EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0501 +#define EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0502 +#define EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0504 +#define EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER 0x0508 +#define EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0510 +#define EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0520 +#define EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0540 +#define EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER 0x0580 +#define EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0601 +#define EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0602 +#define EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER 0x0604 +#define EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0608 +#define EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER 0x0610 +#define EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0620 +#define EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER 0x0640 +#define EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0680 +#define EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER 0x0701 +#define EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER 0x0702 +#define EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER 0x0704 +#define EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER 0x0708 +#define EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER 0x0710 +#define EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER 0x0720 +#define EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0740 +#define EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0780 +#define EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0801 +#define EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER 0x0802 +#define EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER 0x0804 +#define EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER 0x0808 +#define EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER 0x0810 +#define EMBER_AF_PRINT_IAS_ZONE_CLUSTER 0x0820 +#define EMBER_AF_PRINT_IAS_ACE_CLUSTER 0x0840 +#define EMBER_AF_PRINT_IAS_WD_CLUSTER 0x0880 +#define EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER 0x0901 +#define EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER 0x0902 +#define EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER 0x0904 +#define EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER 0x0908 +#define EMBER_AF_PRINT_PRICE_CLUSTER 0x0910 +#define EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER 0x0920 +#define EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER 0x0940 +#define EMBER_AF_PRINT_MESSAGING_CLUSTER 0x0980 +#define EMBER_AF_PRINT_TUNNELING_CLUSTER 0x0A01 +#define EMBER_AF_PRINT_PREPAYMENT_CLUSTER 0x0A02 +#define EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER 0x0A04 +#define EMBER_AF_PRINT_CALENDAR_CLUSTER 0x0A08 +#define EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER 0x0A10 +#define EMBER_AF_PRINT_EVENTS_CLUSTER 0x0A20 +#define EMBER_AF_PRINT_MDU_PAIRING_CLUSTER 0x0A40 +#define EMBER_AF_PRINT_SUB_GHZ_CLUSTER 0x0A80 +#define EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER 0x0B01 +#define EMBER_AF_PRINT_INFORMATION_CLUSTER 0x0B02 +#define EMBER_AF_PRINT_DATA_SHARING_CLUSTER 0x0B04 +#define EMBER_AF_PRINT_GAMING_CLUSTER 0x0B08 +#define EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER 0x0B10 +#define EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER 0x0B20 +#define EMBER_AF_PRINT_CHATTING_CLUSTER 0x0B40 +#define EMBER_AF_PRINT_PAYMENT_CLUSTER 0x0B80 +#define EMBER_AF_PRINT_BILLING_CLUSTER 0x0C01 +#define EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER 0x0C02 +#define EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER 0x0C04 +#define EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER 0x0C08 +#define EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER 0x0C10 +#define EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER 0x0C20 +#define EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER 0x0C40 +#define EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER 0x0C80 +#define EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER 0x0D01 +#define EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2 0x0D02 +#define EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER 0x0D04 +#define EMBER_AF_PRINT_MFGLIB_CLUSTER 0x0D08 +#define EMBER_AF_PRINT_SL_WWAH_CLUSTER 0x0D10 +#define EMBER_AF_PRINT_CORE 0x0D20 +#define EMBER_AF_PRINT_DEBUG 0x0D40 +#define EMBER_AF_PRINT_APP 0x0D80 +#define EMBER_AF_PRINT_SECURITY 0x0E01 +#define EMBER_AF_PRINT_ATTRIBUTES 0x0E02 +#define EMBER_AF_PRINT_REPORTING 0x0E04 +#define EMBER_AF_PRINT_SERVICE_DISCOVERY 0x0E08 +#define EMBER_AF_PRINT_REGISTRATION 0x0E10 +#define EMBER_AF_PRINT_ZDO 0x0E20 +#define EMBER_AF_PRINT_CUSTOM1 0x0E40 +#define EMBER_AF_PRINT_CUSTOM2 0x0E80 +#define EMBER_AF_PRINT_CUSTOM3 0x0F01 + +#define EMBER_AF_PRINT_OUTPUT 1 + +#define EMBER_AF_PRINT_NAMES \ + { \ + "Basic", "Power Configuration", "Device Temperature Configuration", "Identify", "Groups", "Scenes", "On/off", \ + "On/off Switch Configuration", "Level Control", "Alarms", "Time", "RSSI Location", "Binary Input (Basic)", \ + "Commissioning", "Partition", "Over the Air Bootloading", "Power Profile", "Appliance Control", "Poll Control", \ + "Green Power", "Keep-Alive", "Shade Configuration", "Door Lock", "Window Covering", "Barrier Control", \ + "Pump Configuration and Control", "Thermostat", "Fan Control", "Dehumidification Control", \ + "Thermostat User Interface Configuration", "Color Control", "Ballast Configuration", "Illuminance Measurement", \ + "Illuminance Level Sensing", "Temperature Measurement", "Pressure Measurement", "Flow Measurement", \ + "Relative Humidity Measurement", "Occupancy Sensing", "Carbon Monoxide Concentration Measurement", \ + "Carbon Dioxide Concentration Measurement", "Ethylene Concentration Measurement", \ + "Ethylene Oxide Concentration Measurement", "Hydrogen Concentration Measurement", \ + "Hydrogen Sulphide Concentration Measurement", "Nitric Oxide Concentration Measurement", \ + "Nitrogen Dioxide Concentration Measurement", "Oxygen Concentration Measurement", "Ozone Concentration Measurement", \ + "Sulfur Dioxide Concentration Measurement", "Dissolved Oxygen Concentration Measurement", \ + "Bromate Concentration Measurement", "Chloramines Concentration Measurement", "Chlorine Concentration Measurement", \ + "Fecal coliform and E. Coli Concentration Measurement", "Fluoride Concentration Measurement", \ + "Haloacetic Acids Concentration Measurement", "Total Trihalomethanes Concentration Measurement", \ + "Total Coliform Bacteria Concentration Measurement", "Turbidity Concentration Measurement", \ + "Copper Concentration Measurement", "Lead Concentration Measurement", "Manganese Concentration Measurement", \ + "Sulfate Concentration Measurement", "Bromodichloromethane Concentration Measurement", \ + "Bromoform Concentration Measurement", "Chlorodibromomethane Concentration Measurement", \ + "Chloroform Concentration Measurement", "Sodium Concentration Measurement", "IAS Zone", "IAS ACE", "IAS WD", \ + "Generic Tunnel", "BACnet Protocol Tunnel", "11073 Protocol Tunnel", "ISO 7816 Protocol Tunnel", "Price", \ + "Demand Response and Load Control", "Simple Metering", "Messaging", "Tunneling", "Prepayment", "Energy Management", \ + "Calendar", "Device Management", "Events", "MDU Pairing", "Sub-GHz", "Key Establishment", "Information", \ + "Data Sharing", "Gaming", "Data Rate Control", "Voice over ZigBee", "Chatting", "Payment", "Billing", \ + "Appliance Identification", "Meter Identification", "Appliance Events and Alert", "Appliance Statistics", \ + "Electrical Measurement", "Diagnostics", "ZLL Commissioning", "Sample Mfg Specific Cluster", \ + "Sample Mfg Specific Cluster 2", "Configuration Cluster", "MFGLIB Cluster", "SL Works With All Hubs", "Core", "Debug", \ + "Application", "Security", "Attributes", "Reporting", "Service discovery", "Registration", \ + "ZDO (ZigBee Device Object)", "Custom messages (1)", "Custom messages (2)", "Custom messages (3)" \ + } + +#define EMBER_AF_PRINT_NAME_NUMBER 121 +#define EMBER_AF_PRINT_BITS \ + { \ + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF \ + } + +#endif // SILABS_EMBER_AF_PRINTING_TEST diff --git a/examples/temperature-measurement-app/esp32/main/gen/debug-printing.h b/examples/temperature-measurement-app/esp32/main/gen/debug-printing.h new file mode 100644 index 00000000000000..f5a958b9521e5d --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/debug-printing.h @@ -0,0 +1,2924 @@ +/** + * + * 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. + */ +// 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 + +#include "debug-printing-test.h" + +// 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/temperature-measurement-app/esp32/main/gen/endpoint_config.h b/examples/temperature-measurement-app/esp32/main/gen/endpoint_config.h new file mode 100644 index 00000000000000..118dc8e730b4f2 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/endpoint_config.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. + */ +// 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 \ + { \ + { \ + 0xFFFD, ZCL_INT16U_ATTRIBUTE_TYPE, 2, (ATTRIBUTE_MASK_CLIENT | ATTRIBUTE_MASK_SINGLETON), { (uint8_t *) 0x0001 } \ + }, /* 0 / Basic / cluster revision*/ \ + { \ + 0x0000, ZCL_INT8U_ATTRIBUTE_TYPE, 1, (ATTRIBUTE_MASK_SINGLETON), { (uint8_t *) 0x03 } \ + }, /* 1 / Basic / ZCL version*/ \ + { \ + 0x0007, ZCL_ENUM8_ATTRIBUTE_TYPE, 1, (ATTRIBUTE_MASK_SINGLETON), { (uint8_t *) 0x00 } \ + }, /* 2 / Basic / power source*/ \ + { \ + 0xFFFD, ZCL_INT16U_ATTRIBUTE_TYPE, 2, (ATTRIBUTE_MASK_SINGLETON), { (uint8_t *) 0x0001 } \ + }, /* 3 / Basic / cluster revision*/ \ + { \ + 0xFFFD, ZCL_INT16U_ATTRIBUTE_TYPE, 2, (ATTRIBUTE_MASK_CLIENT), { (uint8_t *) 0x0001 } \ + }, /* 4 / Temperature Measurement / cluster revision*/ \ + { \ + 0x0000, ZCL_INT16S_ATTRIBUTE_TYPE, 2, (0x00), { (uint8_t *) 0x0000 } \ + }, /* 5 / Temperature Measurement / measured value*/ \ + { \ + 0x0001, ZCL_INT16S_ATTRIBUTE_TYPE, 2, (0x00), { (uint8_t *) 0x0000L } \ + }, /* 6 / Temperature Measurement / min measured value*/ \ + { \ + 0x0002, ZCL_INT16S_ATTRIBUTE_TYPE, 2, (0x00), { (uint8_t *) 0x0000L } \ + }, /* 7 / Temperature Measurement / max measured value*/ \ + { \ + 0xFFFD, ZCL_INT16U_ATTRIBUTE_TYPE, 2, (0x00), { (uint8_t *) 0x0001 } \ + }, /* 8 / Temperature Measurement / cluster revision*/ \ + } + +// Cluster function static arrays +#define GENERATED_FUNCTION_ARRAYS + +// Clusters definitions +#define GENERATED_CLUSTERS \ + { \ + { \ + 0x0000, (EmberAfAttributeMetadata *) &(generatedAttributes[0]), 1, 0, (CLUSTER_MASK_CLIENT), NULL, \ + }, \ + { \ + 0x0000, (EmberAfAttributeMetadata *) &(generatedAttributes[1]), 3, 0, (CLUSTER_MASK_SERVER), NULL, \ + }, \ + { \ + 0x0402, (EmberAfAttributeMetadata *) &(generatedAttributes[4]), 1, 2, (CLUSTER_MASK_CLIENT), NULL, \ + }, \ + { \ + 0x0402, (EmberAfAttributeMetadata *) &(generatedAttributes[5]), 4, 8, (CLUSTER_MASK_SERVER), NULL, \ + }, \ + } + +// Endpoint types +#define GENERATED_ENDPOINT_TYPES \ + { \ + { (EmberAfCluster *) &(generatedClusters[0]), 4, 10 }, \ + } + +// 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 (6) + +// Total size of attribute storage +#define ATTRIBUTE_MAX_SIZE 10 + +// 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_INIT_FUNCTION_DECLARATIONS void emberAfPluginTemperatureMeasurementServerInitCallback(void); + +#define EMBER_AF_GENERATED_PLUGIN_INIT_FUNCTION_CALLS emberAfPluginTemperatureMeasurementServerInitCallback(); + +#define EMBER_AF_GENERATED_PLUGIN_STACK_STATUS_FUNCTION_DECLARATIONS \ + void emberAfPluginTemperatureMeasurementServerStackStatusCallback(EmberStatus status); + +#define EMBER_AF_GENERATED_PLUGIN_STACK_STATUS_FUNCTION_CALLS emberAfPluginTemperatureMeasurementServerStackStatusCallback(status); + +// Generated reporting configuration defaults +#define EMBER_AF_GENERATED_REPORTING_CONFIG_DEFAULTS \ + { \ + { EMBER_ZCL_REPORTING_DIRECTION_REPORTED, 1, 0x0402, 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/temperature-measurement-app/esp32/main/gen/enums.h b/examples/temperature-measurement-app/esp32/main/gen/enums.h new file mode 100644 index 00000000000000..9dac5d5249e2c5 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/enums.h @@ -0,0 +1,3553 @@ +/** + * + * 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. + */ +// 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/temperature-measurement-app/esp32/main/gen/gen_config.h b/examples/temperature-measurement-app/esp32/main/gen/gen_config.h new file mode 100644 index 00000000000000..76c96fceb417a9 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/gen_config.h @@ -0,0 +1,194 @@ +/** + * + * 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. + */ +// 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 + +#include "debug-printing-test.h" + +/**** 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 "CHIPv1Clusters" +#define ZCL_USING_BASIC_CLUSTER_CLIENT +#define ZCL_USING_BASIC_CLUSTER_SERVER +#define ZCL_USING_TEMP_MEASUREMENT_CLUSTER_CLIENT +#define ZCL_USING_TEMP_MEASUREMENT_CLUSTER_SERVER +#define EMBER_AF_MANUFACTURER_CODE 0x1002 +#define EMBER_AF_DEFAULT_RESPONSE_POLICY_ALWAYS + +/**** Cluster endpoint counts ****/ +#define EMBER_AF_BASIC_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_BASIC_CLUSTER_SERVER_ENDPOINT_COUNT (1) +#define EMBER_AF_TEMP_MEASUREMENT_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_TEMP_MEASUREMENT_CLUSTER_SERVER_ENDPOINT_COUNT (1) + +/**** Cluster Endpoint Summaries ****/ +#define EMBER_AF_MAX_SERVER_CLUSTER_COUNT (2) +#define EMBER_AF_MAX_CLIENT_CLUSTER_COUNT (2) +#define EMBER_AF_MAX_TOTAL_CLUSTER_COUNT (4) + +/**** 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_ZC_AND_ZR_DEVICE_COUNT (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_TEMPERATURE_READING_COMPLETE +#define EMBER_CALLBACK_BASIC_CLUSTER_RESET_TO_FACTORY_DEFAULTS +/**** Debug printing section ****/ + +// Global switch +#define EMBER_AF_PRINT_ENABLE +// Individual areas + +// 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 Basic Server Cluster plugin is included +#define EMBER_AF_PLUGIN_BASIC + +// 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 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 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 Temperature Measurement Server Cluster plugin is included +#define EMBER_AF_PLUGIN_TEMPERATURE_MEASUREMENT_SERVER +// User options for plugin Temperature Measurement Server Cluster +#define EMBER_AF_PLUGIN_TEMPERATURE_MEASUREMENT_SERVER_MAX_MEASUREMENT_FREQUENCY_S 300 +#define EMBER_AF_PLUGIN_TEMPERATURE_MEASUREMENT_SERVER_DEFAULT_REPORTABLE_TEMPERATURE_CHANGE_M_C 500 +#define EMBER_AF_PLUGIN_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE +#define EMBER_AF_PLUGIN_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE_ASSERT_WARNING_THRESHOLD 55 +#define EMBER_AF_PLUGIN_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE_DEASSERT_WARNING_THRESHOLD 50 +#define EMBER_AF_PLUGIN_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE_ASSERT_CRITICAL_THRESHOLD 60 +#define EMBER_AF_PLUGIN_TEMPERATURE_MEASUREMENT_SERVER_OVER_TEMPERATURE_DEASSERT_CRITICAL_THRESHOLD 55 + +// Use this macro to check if Temperature Si7053 Stub plugin is included +#define EMBER_AF_PLUGIN_TEMPERATURE_SI7053_STUB + +// 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 temperature from Temperature Si7053 Stub plugin +#define EMBER_AF_API_TEMPERATURE \ + "../../../../../Applications/Simplicity " \ + "Studio.app/Contents/Eclipse/developer/sdks/gecko_sdk_suite/v3.0/platform/base/hal/plugin/temperature/temperature.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/temperature-measurement-app/esp32/main/gen/gen_tokens.h b/examples/temperature-measurement-app/esp32/main/gen/gen_tokens.h new file mode 100644 index 00000000000000..49437d25113ebd --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/gen_tokens.h @@ -0,0 +1,43 @@ +/** + * + * 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. + */ +// 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/temperature-measurement-app/esp32/main/gen/print-cluster.h b/examples/temperature-measurement-app/esp32/main/gen/print-cluster.h new file mode 100644 index 00000000000000..1555aa02ed2645 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/print-cluster.h @@ -0,0 +1,761 @@ +/** + * + * 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. + */ +// 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/temperature-measurement-app/esp32/main/gen/znet-bookkeeping.c b/examples/temperature-measurement-app/esp32/main/gen/znet-bookkeeping.c new file mode 100644 index 00000000000000..ee13fee147c3f6 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/znet-bookkeeping.c @@ -0,0 +1,100 @@ +/** + * + * 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. + */ +// 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 emAfMarkBuffers(void) +{ + emberAfMarkBuffersCallback(); // Global +} + +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 emAfZigbeeKeyEstablishment(EmberEUI64 partner, EmberKeyStatus status) +{ + emberAfZigbeeKeyEstablishmentCallback(partner, status); // Global +} + +// 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/temperature-measurement-app/esp32/main/gen/znet-bookkeeping.h b/examples/temperature-measurement-app/esp32/main/gen/znet-bookkeeping.h new file mode 100644 index 00000000000000..20b9f2eb2a2daa --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/gen/znet-bookkeeping.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. + */ +// 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" + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +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); + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif // SILABS_ZNET_BOOKKEEPING_H diff --git a/examples/temperature-measurement-app/esp32/main/include/CHIPDeviceManager.h b/examples/temperature-measurement-app/esp32/main/include/CHIPDeviceManager.h new file mode 100644 index 00000000000000..a2575de0498fa1 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/include/CHIPDeviceManager.h @@ -0,0 +1,127 @@ +/* + * + * 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. + */ + +/** + * @file + * This file contains definitions for the CHIP DeviceManager Interface + * + * This object will co-ordinate multiple activities such as + * initialisation, rendezvous, session mgmt and other such + * activities within the CHIP stack. This is a singleton object. + */ + +#ifndef CHIP_DEVICEMANAGER_H_ +#define CHIP_DEVICEMANAGER_H_ + +#include +#include +#include + +#include + +#include +#include + +#include "af-types.h" + +namespace chip { +namespace DeviceManager { + +/** + * @brief + * This class provides a skeleton for all the callback functions. The functions will be + * called by other objects within the CHIP stack for specific events. + * Applications interested in receiving specific callbacks can specialize this class and handle + * these events in their implementation of this class. + */ +class DLL_EXPORT CHIPDeviceManagerCallbacks +{ +public: + /** + * @brief + * Called when CHIP Device events (PublicEventTypes) are triggered. + * + * @param event ChipDeviceEvent that occurred + * @param arg arguments specific to the event, if any + */ + virtual void DeviceEventCallback(const chip::DeviceLayer::ChipDeviceEvent * event, intptr_t arg); + + /** + * @brief + * Called after an attribute has been changed + * + * @param endpoint endpoint id + * @param clusterID cluster id + * @param attributeId attribute id that was changed + * @param mask mask of the attribute + * @param manufacturerCode manufacturer code + * @param type attribute type + * @param size size of the attribute + * @param value pointer to the new value + */ + 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() {} +}; + +/** + * @brief + * A common class that drives other components of the CHIP stack + */ +class DLL_EXPORT CHIPDeviceManager +{ +public: + CHIPDeviceManager(const CHIPDeviceManager &) = delete; + CHIPDeviceManager(const CHIPDeviceManager &&) = delete; + CHIPDeviceManager & operator=(const CHIPDeviceManager &) = delete; + + static CHIPDeviceManager & GetInstance() + { + static CHIPDeviceManager instance; + return instance; + } + + /** + * @brief + * Initialise CHIPDeviceManager + * + * @param cb Application's instance of the CHIPDeviceManagerCallbacks for consuming events + */ + CHIP_ERROR Init(CHIPDeviceManagerCallbacks * cb); + + /** + * @brief + * Fetch a pointer to the registered CHIPDeviceManagerCallbacks object. + * + */ + CHIPDeviceManagerCallbacks * GetCHIPDeviceManagerCallbacks() { return mCB; } + + /** + * Use internally for registration of the ChipDeviceEvents + */ + static void CommonDeviceEventHandler(const chip::DeviceLayer::ChipDeviceEvent * event, intptr_t arg); + +private: + CHIPDeviceManagerCallbacks * mCB = nullptr; + CHIPDeviceManager() {} +}; + +} // namespace DeviceManager +} // namespace chip + +#endif /* CHIP_DEVICEMANAGER_H_ */ diff --git a/examples/temperature-measurement-app/esp32/main/include/DataModelHandler.h b/examples/temperature-measurement-app/esp32/main/include/DataModelHandler.h new file mode 100644 index 00000000000000..455f1c89dd632c --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/include/DataModelHandler.h @@ -0,0 +1,54 @@ +/* + * + * 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. + */ + +/** + * @file + * This file defines the API for the handler for data model messages. + */ + +#ifndef DATA_MODEL_HANDLER_H +#define DATA_MODEL_HANDLER_H + +namespace chip { +namespace System { +class PacketBuffer; +} // namespace System + +class SecureSessionMgrBase; +class MessageHeader; +} // namespace chip + +/** + * Initialize the data model handler. This must be called once, and before any + * HandleDataModelMessage calls happen. + */ +void InitDataModelHandler(); + +/** + * Handle a message that should be processed via our data model processing + * codepath. + * + * @param[in] header The message header for the incoming message. + * @param[in] buffer The buffer holding the message. This function guarantees + * that it will free the buffer before returning. + * @param[in] mgr The session manager to use for sending a response to the + * message. + */ +void HandleDataModelMessage(const chip::PacketHeader & header, chip::System::PacketBuffer * buffer, + chip::SecureSessionMgrBase * mgr); + +#endif // DATA_MODEL_HANDLER_H diff --git a/examples/temperature-measurement-app/esp32/main/include/DeviceCallbacks.h b/examples/temperature-measurement-app/esp32/main/include/DeviceCallbacks.h new file mode 100644 index 00000000000000..7cd1aa88f610fd --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/include/DeviceCallbacks.h @@ -0,0 +1,47 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * All rights reserved. + * + * 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 DeviceCallbacks.h + * + * Implementations for the DeviceManager callbacks for this application + * + **/ + +#ifndef DEVICE_CALLBACKS_H +#define DEVICE_CALLBACKS_H + +#include "CHIPDeviceManager.h" +#include +#include + +class DeviceCallbacks : public chip::DeviceManager::CHIPDeviceManagerCallbacks +{ +public: + virtual void DeviceEventCallback(const chip::DeviceLayer::ChipDeviceEvent * event, intptr_t arg); + virtual void PostAttributeChangeCallback(uint8_t endpointId, EmberAfClusterId clusterId, EmberAfAttributeId attributeId, + uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value); + +private: + void OnInternetConnectivityChange(const chip::DeviceLayer::ChipDeviceEvent * event); + void OnSessionEstablished(const chip::DeviceLayer::ChipDeviceEvent * event); + void OnOnOffPostAttributeChangeCallback(uint8_t endpointId, uint16_t attributeId, uint8_t * value); + void OnIdentifyPostAttributeChangeCallback(uint8_t endpointId, uint16_t attributeId, uint8_t * value); +}; + +#endif // DEVICE_CALLBACKS_H diff --git a/examples/temperature-measurement-app/esp32/main/include/DeviceNetworkProvisioningDelegate.h b/examples/temperature-measurement-app/esp32/main/include/DeviceNetworkProvisioningDelegate.h new file mode 100644 index 00000000000000..a3d5cc13fc7e0d --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/include/DeviceNetworkProvisioningDelegate.h @@ -0,0 +1,39 @@ +/* + * + * 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 _DEVICE_NETWORK_PROVISIONING_DELEGATE_H_ +#define _DEVICE_NETWORK_PROVISIONING_DELEGATE_H_ + +#include +#include + +using namespace ::chip; + +class ESP32NetworkProvisioningDelegate : public DeviceNetworkProvisioningDelegate +{ +public: + /** + * @brief + * Called to provision WiFi credentials in a device + * + * @param ssid WiFi SSID + * @param passwd WiFi password + */ + void ProvisionNetwork(const char * ssid, const char * passwd) override; +}; + +#endif // _DEVICE_NETWORK_PROVISIONING_DELEGATE_H_ diff --git a/examples/temperature-measurement-app/esp32/main/include/RendezvousDeviceDelegate.h b/examples/temperature-measurement-app/esp32/main/include/RendezvousDeviceDelegate.h new file mode 100644 index 00000000000000..56bc657c5e4c6a --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/include/RendezvousDeviceDelegate.h @@ -0,0 +1,40 @@ +/* + * + * 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 __RENDEZVOUSDEVICEDELEGATE_H__ +#define __RENDEZVOUSDEVICEDELEGATE_H__ + +#include "DeviceNetworkProvisioningDelegate.h" + +#include +#include + +class RendezvousDeviceDelegate : public chip::RendezvousSessionDelegate +{ +public: + RendezvousDeviceDelegate(); + + //////////// RendezvousSession callback Implementation /////////////// + void OnRendezvousMessageReceived(chip::System::PacketBuffer * buffer) override; + void OnRendezvousStatusUpdate(RendezvousSessionDelegate::Status status, CHIP_ERROR err) override; + +private: + chip::RendezvousSession * mRendezvousSession; + ESP32NetworkProvisioningDelegate mDeviceNetworkProvisioningDelegate; +}; + +#endif // __RENDEZVOUSDEVICEDELEGATE_H__ diff --git a/examples/temperature-measurement-app/esp32/main/include/RendezvousMessageHandler.h b/examples/temperature-measurement-app/esp32/main/include/RendezvousMessageHandler.h new file mode 100644 index 00000000000000..8fca6fa44648ed --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/include/RendezvousMessageHandler.h @@ -0,0 +1,36 @@ +/* + * + * 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 _RENDEZVOUS_MESSAGE_HANDLER_H +#define _RENDEZVOUS_MESSAGE_HANDLER_H + +#include +#include + +using namespace ::chip; + +class RendezvousMessageHandler +{ +public: + // Handle a rendezvous message. Returns: + // - CHIP_NO_ERROR if the message was handled successfully. + // - CHIP_ERROR_INVALID_MESSAGE_TYPE if the message was not recognized. + // - Some other error encountered processing a specific message type. + static CHIP_ERROR HandleMessageReceived(System::PacketBuffer * buffer); +}; + +#endif // _RENDEZVOUS_MESSAGE_HANDLER_H diff --git a/examples/temperature-measurement-app/esp32/main/wifi-echo.cpp b/examples/temperature-measurement-app/esp32/main/wifi-echo.cpp new file mode 100644 index 00000000000000..8a75154682101e --- /dev/null +++ b/examples/temperature-measurement-app/esp32/main/wifi-echo.cpp @@ -0,0 +1,133 @@ +/* + * + * 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 "CHIPDeviceManager.h" +#include "DataModelHandler.h" +#include "DeviceCallbacks.h" +#include "RendezvousDeviceDelegate.h" +#include "esp_heap_caps_init.h" +#include "esp_log.h" +#include "esp_netif.h" +#include "esp_spi_flash.h" +#include "esp_system.h" +#include "esp_wifi.h" +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "nvs_flash.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +using namespace ::chip; +using namespace ::chip::DeviceManager; +using namespace ::chip::DeviceLayer; + +extern void startServer(); + +// Used to indicate that an IP address has been added to the QRCode +#define EXAMPLE_VENDOR_TAG_IP 1 + +extern void PairingComplete(SecurePairingSession * pairing); + +const char * TAG = "wifi-echo-demo"; + +static DeviceCallbacks EchoCallbacks; +RendezvousDeviceDelegate * rendezvousDelegate = nullptr; + +namespace { + +bool isRendezvousBLE() +{ + return static_cast(CONFIG_RENDEZVOUS_MODE) == RendezvousInformationFlags::kBLE; +} + +bool isRendezvousBypassed() +{ + return static_cast(CONFIG_RENDEZVOUS_MODE) == RendezvousInformationFlags::kNone; +} + +static SecurePairingUsingTestSecret gTestPairing; + +} // namespace + +extern "C" void app_main() +{ + ESP_LOGI(TAG, "Temperature sensor!"); + + /* Print chip information */ + esp_chip_info_t chip_info; + esp_chip_info(&chip_info); + + ESP_LOGI(TAG, "This is ESP32 chip with %d CPU cores, WiFi%s%s, ", chip_info.cores, + (chip_info.features & CHIP_FEATURE_BT) ? "/BT" : "", (chip_info.features & CHIP_FEATURE_BLE) ? "/BLE" : ""); + + ESP_LOGI(TAG, "silicon revision %d, ", chip_info.revision); + + ESP_LOGI(TAG, "%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024), + (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external"); + + CHIP_ERROR err; // A quick note about errors: CHIP adopts the error type and numbering + // convention of the environment into which it is ported. Thus esp_err_t + // and CHIP_ERROR are in fact the same type, and both ESP-IDF errors + // and CHIO-specific errors can be stored in the same value without + // ambiguity. For convenience, ESP_OK and CHIP_NO_ERROR are mapped + // to the same value. + + // Initialize the ESP NVS layer. + err = nvs_flash_init(); + if (err != CHIP_NO_ERROR) + { + ESP_LOGE(TAG, "nvs_flash_init() failed: %s", ErrorStr(err)); + return; + } + + CHIPDeviceManager & deviceMgr = CHIPDeviceManager::GetInstance(); + + err = deviceMgr.Init(&EchoCallbacks); + if (err != CHIP_NO_ERROR) + { + ESP_LOGE(TAG, "device.Init() failed: %s", ErrorStr(err)); + return; + } + + InitDataModelHandler(); + startServer(); + + if (isRendezvousBLE()) + { + rendezvousDelegate = new RendezvousDeviceDelegate(); + } + else if (isRendezvousBypassed()) + { + ChipLogProgress(Ble, "Rendezvous and Secure Pairing skipped. Using test secret."); + PairingComplete(&gTestPairing); + } + + // Run the UI Loop + while (true) + { + vTaskDelay(50 / portTICK_PERIOD_MS); + } +} diff --git a/examples/temperature-measurement-app/esp32/partitions.csv b/examples/temperature-measurement-app/esp32/partitions.csv new file mode 100644 index 00000000000000..b338ff11a11589 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/partitions.csv @@ -0,0 +1,6 @@ +# Name, Type, SubType, Offset, Size, Flags +# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap +nvs, data, nvs, , 0x6000, +phy_init, data, phy, , 0x1000, +# Factory partition size about 1.9MB +factory, app, factory, , 1945K, diff --git a/examples/temperature-measurement-app/esp32/sdkconfig.defaults b/examples/temperature-measurement-app/esp32/sdkconfig.defaults new file mode 100644 index 00000000000000..77969f49798d47 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/sdkconfig.defaults @@ -0,0 +1,38 @@ +# +# Copyright (c) 2020 Project CHIP Authors +# Copyright (c) 2018 Nest Labs, Inc. +# All rights reserved. +# +# 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: +# Some useful defaults for the demo app configuration. +# + + +# Default to 921600 baud when flashing and monitoring device +CONFIG_ESPTOOLPY_BAUD_921600B=y +CONFIG_ESPTOOLPY_BAUD=921600 +CONFIG_ESPTOOLPY_COMPRESSED=y +CONFIG_ESPTOOLPY_MONITOR_BAUD_115200B=y +CONFIG_ESPTOOLPY_MONITOR_BAUD=115200 + +#enable BT +CONFIG_BT_ENABLED=y + +#enable lwip ipv6 autoconfig +CONFIG_LWIP_IPV6_AUTOCONFIG=y + +# Use a custom partition table +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" diff --git a/examples/temperature-measurement-app/esp32/sdkconfig_devkit.defaults b/examples/temperature-measurement-app/esp32/sdkconfig_devkit.defaults new file mode 100644 index 00000000000000..336d38da857b99 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/sdkconfig_devkit.defaults @@ -0,0 +1,39 @@ +# +# Copyright (c) 2020 Project CHIP Authors +# Copyright (c) 2018 Nest Labs, Inc. +# All rights reserved. +# +# 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: +# CI uses this to select the ESP32-DevKitC. +# + +CONFIG_DEVICE_TYPE_ESP32_DEVKITC=y + +# Default to 921600 baud when flashing and monitoring device +CONFIG_ESPTOOLPY_BAUD_921600B=y +CONFIG_ESPTOOLPY_BAUD=921600 +CONFIG_ESPTOOLPY_COMPRESSED=y +CONFIG_ESPTOOLPY_MONITOR_BAUD_115200B=y +CONFIG_ESPTOOLPY_MONITOR_BAUD=115200 + +#enable BT +CONFIG_BT_ENABLED=y + +#enable lwip ipv6 autoconfig +CONFIG_LWIP_IPV6_AUTOCONFIG=y + +# Use a custom partition table +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" diff --git a/examples/temperature-measurement-app/esp32/sdkconfig_m5stack.defaults b/examples/temperature-measurement-app/esp32/sdkconfig_m5stack.defaults new file mode 100644 index 00000000000000..ca53405dcc9842 --- /dev/null +++ b/examples/temperature-measurement-app/esp32/sdkconfig_m5stack.defaults @@ -0,0 +1,39 @@ +# +# Copyright (c) 2020 Project CHIP Authors +# Copyright (c) 2018 Nest Labs, Inc. +# All rights reserved. +# +# 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: +# CI uses this to select the ESP32 M5Stack. +# + +CONFIG_DEVICE_TYPE_M5STACK=y + +# Default to 921600 baud when flashing and monitoring device +CONFIG_ESPTOOLPY_BAUD_921600B=y +CONFIG_ESPTOOLPY_BAUD=921600 +CONFIG_ESPTOOLPY_COMPRESSED=y +CONFIG_ESPTOOLPY_MONITOR_BAUD_115200B=y +CONFIG_ESPTOOLPY_MONITOR_BAUD=115200 + +#enable BT +CONFIG_BT_ENABLED=y + +#enable lwip ipv6 autoconfig +CONFIG_LWIP_IPV6_AUTOCONFIG=y + +# Use a custom partition table +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" diff --git a/examples/temperature-measurement-app/esp32/third_party/connectedhomeip b/examples/temperature-measurement-app/esp32/third_party/connectedhomeip new file mode 120000 index 00000000000000..11a54ed360106c --- /dev/null +++ b/examples/temperature-measurement-app/esp32/third_party/connectedhomeip @@ -0,0 +1 @@ +../../../../ \ No newline at end of file