blob: 65ccb96743ea502f30a2a3f438574d70adb802fb [file] [log] [blame]
/**
*
* 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.
//
//
#pragma once
#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_CONFIGURATION_CLUSTER)
#define emberAfOnOffSwitchConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIGURATION_CLUSTER, __VA_ARGS__)
#define emberAfOnOffSwitchConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIGURATION_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_CONFIGURATION_CLUSTER)) \
{ \
x; \
}
#define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace) \
emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace))
#define emberAfOnOffSwitchConfigClusterPrintString(buffer) \
emberAfPrintString(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIGURATION_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_CONFIGURATION_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_CONFIGURATION_AND_CONTROL_CLUSTER)
#define emberAfPumpConfigControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PUMP_CONFIGURATION_AND_CONTROL_CLUSTER, __VA_ARGS__)
#define emberAfPumpConfigControlClusterPrintln(...) \
emberAfPrintln(EMBER_AF_PRINT_PUMP_CONFIGURATION_AND_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_CONFIGURATION_AND_CONTROL_CLUSTER)) \
{ \
x; \
}
#define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace) \
emberAfPrintBuffer(EMBER_AF_PRINT_PUMP_CONFIGURATION_AND_CONTROL_CLUSTER, (buffer), (len), (withSpace))
#define emberAfPumpConfigControlClusterPrintString(buffer) \
emberAfPrintString(EMBER_AF_PRINT_PUMP_CONFIGURATION_AND_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_CONFIGURATION_AND_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_USER_INTERFACE_CONFIGURATION_CLUSTER)
#define emberAfThermostatUiConfigClusterPrint(...) \
emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLUSTER, __VA_ARGS__)
#define emberAfThermostatUiConfigClusterPrintln(...) \
emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_USER_INTERFACE_CONFIGURATION_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_USER_INTERFACE_CONFIGURATION_CLUSTER)) \
{ \
x; \
}
#define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace) \
emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace))
#define emberAfThermostatUiConfigClusterPrintString(buffer) \
emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_USER_INTERFACE_CONFIGURATION_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_USER_INTERFACE_CONFIGURATION_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_TEMPERATURE_MEASUREMENT_CLUSTER)
#define emberAfTempMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TEMPERATURE_MEASUREMENT_CLUSTER, __VA_ARGS__)
#define emberAfTempMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TEMPERATURE_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_TEMPERATURE_MEASUREMENT_CLUSTER)) \
{ \
x; \
}
#define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace) \
emberAfPrintBuffer(EMBER_AF_PRINT_TEMPERATURE_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
#define emberAfTempMeasurementClusterPrintString(buffer) \
emberAfPrintString(EMBER_AF_PRINT_TEMPERATURE_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_TEMPERATURE_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: 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: Application Basic
#if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLICATION_BASIC_CLUSTER)
#define emberAfApplicationBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLICATION_BASIC_CLUSTER, __VA_ARGS__)
#define emberAfApplicationBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLICATION_BASIC_CLUSTER, __VA_ARGS__)
// Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
#define emberAfApplicationBasicClusterFlush()
#define emberAfApplicationBasicClusterDebugExec(x) \
if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLICATION_BASIC_CLUSTER)) \
{ \
x; \
}
#define emberAfApplicationBasicClusterPrintBuffer(buffer, len, withSpace) \
emberAfPrintBuffer(EMBER_AF_PRINT_APPLICATION_BASIC_CLUSTER, (buffer), (len), (withSpace))
#define emberAfApplicationBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLICATION_BASIC_CLUSTER, (buffer))
#else
#define emberAfApplicationBasicClusterPrint(...)
#define emberAfApplicationBasicClusterPrintln(...)
#define emberAfApplicationBasicClusterFlush()
#define emberAfApplicationBasicClusterDebugExec(x)
#define emberAfApplicationBasicClusterPrintBuffer(buffer, len, withSpace)
#define emberAfApplicationBasicClusterPrintString(buffer)
#endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLICATION_BASIC_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)