src/app/util/debug-printing.h

   1 /**
   2  *
   3  *    Copyright (c) 2020 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 /**
  19  *
  20  *    Copyright (c) 2020 Silicon Labs
  21  *
  22  *    Licensed under the Apache License, Version 2.0 (the "License");
  23  *    you may not use this file except in compliance with the License.
  24  *    You may obtain a copy of the License at
  25  *
  26  *        http://www.apache.org/licenses/LICENSE-2.0
  27  *
  28  *    Unless required by applicable law or agreed to in writing, software
  29  *    distributed under the License is distributed on an "AS IS" BASIS,
  30  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  31  *    See the License for the specific language governing permissions and
  32  *    limitations under the License.
  33  */
  34 // This file is generated by Simplicity Studio.  Please do not edit manually.
  35 //
  36 //
  37
  38 #pragma once
  39
  40 #include "debug-printing-test.h"
  41
  42 // Printing macros for cluster: Basic
  43 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER)
  44 #define emberAfBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BASIC_CLUSTER, __VA_ARGS__)
  45 #define emberAfBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BASIC_CLUSTER, __VA_ARGS__)
  46 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
  47 #define emberAfBasicClusterFlush()
  48 #define emberAfBasicClusterDebugExec(x)                                                                                            \
  49     if (emberAfPrintEnabled(EMBER_AF_PRINT_BASIC_CLUSTER))                                                                         \
  50     {                                                                                                                              \
  51         x;                                                                                                                         \
  52     }
  53 #define emberAfBasicClusterPrintBuffer(buffer, len, withSpace)                                                                     \
  54     emberAfPrintBuffer(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer), (len), (withSpace))
  55 #define emberAfBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BASIC_CLUSTER, (buffer))
  56 #else
  57 #define emberAfBasicClusterPrint(...)
  58 #define emberAfBasicClusterPrintln(...)
  59 #define emberAfBasicClusterFlush()
  60 #define emberAfBasicClusterDebugExec(x)
  61 #define emberAfBasicClusterPrintBuffer(buffer, len, withSpace)
  62 #define emberAfBasicClusterPrintString(buffer)
  63 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BASIC_CLUSTER)
  64
  65 // Printing macros for cluster: Power Configuration
  66 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER)
  67 #define emberAfPowerConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, __VA_ARGS__)
  68 #define emberAfPowerConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, __VA_ARGS__)
  69 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
  70 #define emberAfPowerConfigClusterFlush()
  71 #define emberAfPowerConfigClusterDebugExec(x)                                                                                      \
  72     if (emberAfPrintEnabled(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER))                                                                  \
  73     {                                                                                                                              \
  74         x;                                                                                                                         \
  75     }
  76 #define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace)                                                               \
  77     emberAfPrintBuffer(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer), (len), (withSpace))
  78 #define emberAfPowerConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER, (buffer))
  79 #else
  80 #define emberAfPowerConfigClusterPrint(...)
  81 #define emberAfPowerConfigClusterPrintln(...)
  82 #define emberAfPowerConfigClusterFlush()
  83 #define emberAfPowerConfigClusterDebugExec(x)
  84 #define emberAfPowerConfigClusterPrintBuffer(buffer, len, withSpace)
  85 #define emberAfPowerConfigClusterPrintString(buffer)
  86 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_CONFIG_CLUSTER)
  87
  88 // Printing macros for cluster: Device Temperature Configuration
  89 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER)
  90 #define emberAfDeviceTempClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, __VA_ARGS__)
  91 #define emberAfDeviceTempClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, __VA_ARGS__)
  92 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
  93 #define emberAfDeviceTempClusterFlush()
  94 #define emberAfDeviceTempClusterDebugExec(x)                                                                                       \
  95     if (emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER))                                                                   \
  96     {                                                                                                                              \
  97         x;                                                                                                                         \
  98     }
  99 #define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace)                                                                \
 100     emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer), (len), (withSpace))
 101 #define emberAfDeviceTempClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER, (buffer))
 102 #else
 103 #define emberAfDeviceTempClusterPrint(...)
 104 #define emberAfDeviceTempClusterPrintln(...)
 105 #define emberAfDeviceTempClusterFlush()
 106 #define emberAfDeviceTempClusterDebugExec(x)
 107 #define emberAfDeviceTempClusterPrintBuffer(buffer, len, withSpace)
 108 #define emberAfDeviceTempClusterPrintString(buffer)
 109 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_TEMP_CLUSTER)
 110
 111 // Printing macros for cluster: Identify
 112 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER)
 113 #define emberAfIdentifyClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IDENTIFY_CLUSTER, __VA_ARGS__)
 114 #define emberAfIdentifyClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IDENTIFY_CLUSTER, __VA_ARGS__)
 115 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 116 #define emberAfIdentifyClusterFlush()
 117 #define emberAfIdentifyClusterDebugExec(x)                                                                                         \
 118     if (emberAfPrintEnabled(EMBER_AF_PRINT_IDENTIFY_CLUSTER))                                                                      \
 119     {                                                                                                                              \
 120         x;                                                                                                                         \
 121     }
 122 #define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace)                                                                  \
 123     emberAfPrintBuffer(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer), (len), (withSpace))
 124 #define emberAfIdentifyClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IDENTIFY_CLUSTER, (buffer))
 125 #else
 126 #define emberAfIdentifyClusterPrint(...)
 127 #define emberAfIdentifyClusterPrintln(...)
 128 #define emberAfIdentifyClusterFlush()
 129 #define emberAfIdentifyClusterDebugExec(x)
 130 #define emberAfIdentifyClusterPrintBuffer(buffer, len, withSpace)
 131 #define emberAfIdentifyClusterPrintString(buffer)
 132 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IDENTIFY_CLUSTER)
 133
 134 // Printing macros for cluster: Groups
 135 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER)
 136 #define emberAfGroupsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GROUPS_CLUSTER, __VA_ARGS__)
 137 #define emberAfGroupsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GROUPS_CLUSTER, __VA_ARGS__)
 138 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 139 #define emberAfGroupsClusterFlush()
 140 #define emberAfGroupsClusterDebugExec(x)                                                                                           \
 141     if (emberAfPrintEnabled(EMBER_AF_PRINT_GROUPS_CLUSTER))                                                                        \
 142     {                                                                                                                              \
 143         x;                                                                                                                         \
 144     }
 145 #define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace)                                                                    \
 146     emberAfPrintBuffer(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer), (len), (withSpace))
 147 #define emberAfGroupsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GROUPS_CLUSTER, (buffer))
 148 #else
 149 #define emberAfGroupsClusterPrint(...)
 150 #define emberAfGroupsClusterPrintln(...)
 151 #define emberAfGroupsClusterFlush()
 152 #define emberAfGroupsClusterDebugExec(x)
 153 #define emberAfGroupsClusterPrintBuffer(buffer, len, withSpace)
 154 #define emberAfGroupsClusterPrintString(buffer)
 155 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GROUPS_CLUSTER)
 156
 157 // Printing macros for cluster: Scenes
 158 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER)
 159 #define emberAfScenesClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SCENES_CLUSTER, __VA_ARGS__)
 160 #define emberAfScenesClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SCENES_CLUSTER, __VA_ARGS__)
 161 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 162 #define emberAfScenesClusterFlush()
 163 #define emberAfScenesClusterDebugExec(x)                                                                                           \
 164     if (emberAfPrintEnabled(EMBER_AF_PRINT_SCENES_CLUSTER))                                                                        \
 165     {                                                                                                                              \
 166         x;                                                                                                                         \
 167     }
 168 #define emberAfScenesClusterPrintBuffer(buffer, len, withSpace)                                                                    \
 169     emberAfPrintBuffer(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer), (len), (withSpace))
 170 #define emberAfScenesClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SCENES_CLUSTER, (buffer))
 171 #else
 172 #define emberAfScenesClusterPrint(...)
 173 #define emberAfScenesClusterPrintln(...)
 174 #define emberAfScenesClusterFlush()
 175 #define emberAfScenesClusterDebugExec(x)
 176 #define emberAfScenesClusterPrintBuffer(buffer, len, withSpace)
 177 #define emberAfScenesClusterPrintString(buffer)
 178 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SCENES_CLUSTER)
 179
 180 // Printing macros for cluster: On/off
 181 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER)
 182 #define emberAfOnOffClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_CLUSTER, __VA_ARGS__)
 183 #define emberAfOnOffClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_CLUSTER, __VA_ARGS__)
 184 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 185 #define emberAfOnOffClusterFlush()
 186 #define emberAfOnOffClusterDebugExec(x)                                                                                            \
 187     if (emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_CLUSTER))                                                                        \
 188     {                                                                                                                              \
 189         x;                                                                                                                         \
 190     }
 191 #define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace)                                                                     \
 192     emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer), (len), (withSpace))
 193 #define emberAfOnOffClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ON_OFF_CLUSTER, (buffer))
 194 #else
 195 #define emberAfOnOffClusterPrint(...)
 196 #define emberAfOnOffClusterPrintln(...)
 197 #define emberAfOnOffClusterFlush()
 198 #define emberAfOnOffClusterDebugExec(x)
 199 #define emberAfOnOffClusterPrintBuffer(buffer, len, withSpace)
 200 #define emberAfOnOffClusterPrintString(buffer)
 201 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_CLUSTER)
 202
 203 // Printing macros for cluster: On/off Switch Configuration
 204 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER)
 205 #define emberAfOnOffSwitchConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, __VA_ARGS__)
 206 #define emberAfOnOffSwitchConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, __VA_ARGS__)
 207 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 208 #define emberAfOnOffSwitchConfigClusterFlush()
 209 #define emberAfOnOffSwitchConfigClusterDebugExec(x)                                                                                \
 210     if (emberAfPrintEnabled(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER))                                                          \
 211     {                                                                                                                              \
 212         x;                                                                                                                         \
 213     }
 214 #define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace)                                                         \
 215     emberAfPrintBuffer(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer), (len), (withSpace))
 216 #define emberAfOnOffSwitchConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER, (buffer))
 217 #else
 218 #define emberAfOnOffSwitchConfigClusterPrint(...)
 219 #define emberAfOnOffSwitchConfigClusterPrintln(...)
 220 #define emberAfOnOffSwitchConfigClusterFlush()
 221 #define emberAfOnOffSwitchConfigClusterDebugExec(x)
 222 #define emberAfOnOffSwitchConfigClusterPrintBuffer(buffer, len, withSpace)
 223 #define emberAfOnOffSwitchConfigClusterPrintString(buffer)
 224 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ON_OFF_SWITCH_CONFIG_CLUSTER)
 225
 226 // Printing macros for cluster: Level Control
 227 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER)
 228 #define emberAfLevelControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, __VA_ARGS__)
 229 #define emberAfLevelControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, __VA_ARGS__)
 230 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 231 #define emberAfLevelControlClusterFlush()
 232 #define emberAfLevelControlClusterDebugExec(x)                                                                                     \
 233     if (emberAfPrintEnabled(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER))                                                                 \
 234     {                                                                                                                              \
 235         x;                                                                                                                         \
 236     }
 237 #define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace)                                                              \
 238     emberAfPrintBuffer(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 239 #define emberAfLevelControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER, (buffer))
 240 #else
 241 #define emberAfLevelControlClusterPrint(...)
 242 #define emberAfLevelControlClusterPrintln(...)
 243 #define emberAfLevelControlClusterFlush()
 244 #define emberAfLevelControlClusterDebugExec(x)
 245 #define emberAfLevelControlClusterPrintBuffer(buffer, len, withSpace)
 246 #define emberAfLevelControlClusterPrintString(buffer)
 247 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEVEL_CONTROL_CLUSTER)
 248
 249 // Printing macros for cluster: Alarms
 250 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER)
 251 #define emberAfAlarmClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ALARM_CLUSTER, __VA_ARGS__)
 252 #define emberAfAlarmClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ALARM_CLUSTER, __VA_ARGS__)
 253 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 254 #define emberAfAlarmClusterFlush()
 255 #define emberAfAlarmClusterDebugExec(x)                                                                                            \
 256     if (emberAfPrintEnabled(EMBER_AF_PRINT_ALARM_CLUSTER))                                                                         \
 257     {                                                                                                                              \
 258         x;                                                                                                                         \
 259     }
 260 #define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace)                                                                     \
 261     emberAfPrintBuffer(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer), (len), (withSpace))
 262 #define emberAfAlarmClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ALARM_CLUSTER, (buffer))
 263 #else
 264 #define emberAfAlarmClusterPrint(...)
 265 #define emberAfAlarmClusterPrintln(...)
 266 #define emberAfAlarmClusterFlush()
 267 #define emberAfAlarmClusterDebugExec(x)
 268 #define emberAfAlarmClusterPrintBuffer(buffer, len, withSpace)
 269 #define emberAfAlarmClusterPrintString(buffer)
 270 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ALARM_CLUSTER)
 271
 272 // Printing macros for cluster: Time
 273 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER)
 274 #define emberAfTimeClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TIME_CLUSTER, __VA_ARGS__)
 275 #define emberAfTimeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TIME_CLUSTER, __VA_ARGS__)
 276 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 277 #define emberAfTimeClusterFlush()
 278 #define emberAfTimeClusterDebugExec(x)                                                                                             \
 279     if (emberAfPrintEnabled(EMBER_AF_PRINT_TIME_CLUSTER))                                                                          \
 280     {                                                                                                                              \
 281         x;                                                                                                                         \
 282     }
 283 #define emberAfTimeClusterPrintBuffer(buffer, len, withSpace)                                                                      \
 284     emberAfPrintBuffer(EMBER_AF_PRINT_TIME_CLUSTER, (buffer), (len), (withSpace))
 285 #define emberAfTimeClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TIME_CLUSTER, (buffer))
 286 #else
 287 #define emberAfTimeClusterPrint(...)
 288 #define emberAfTimeClusterPrintln(...)
 289 #define emberAfTimeClusterFlush()
 290 #define emberAfTimeClusterDebugExec(x)
 291 #define emberAfTimeClusterPrintBuffer(buffer, len, withSpace)
 292 #define emberAfTimeClusterPrintString(buffer)
 293 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TIME_CLUSTER)
 294
 295 // Printing macros for cluster: RSSI Location
 296 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER)
 297 #define emberAfRssiLocationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, __VA_ARGS__)
 298 #define emberAfRssiLocationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, __VA_ARGS__)
 299 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 300 #define emberAfRssiLocationClusterFlush()
 301 #define emberAfRssiLocationClusterDebugExec(x)                                                                                     \
 302     if (emberAfPrintEnabled(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER))                                                                 \
 303     {                                                                                                                              \
 304         x;                                                                                                                         \
 305     }
 306 #define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace)                                                              \
 307     emberAfPrintBuffer(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer), (len), (withSpace))
 308 #define emberAfRssiLocationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER, (buffer))
 309 #else
 310 #define emberAfRssiLocationClusterPrint(...)
 311 #define emberAfRssiLocationClusterPrintln(...)
 312 #define emberAfRssiLocationClusterFlush()
 313 #define emberAfRssiLocationClusterDebugExec(x)
 314 #define emberAfRssiLocationClusterPrintBuffer(buffer, len, withSpace)
 315 #define emberAfRssiLocationClusterPrintString(buffer)
 316 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RSSI_LOCATION_CLUSTER)
 317
 318 // Printing macros for cluster: Binary Input (Basic)
 319 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER)
 320 #define emberAfBinaryInputBasicClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, __VA_ARGS__)
 321 #define emberAfBinaryInputBasicClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, __VA_ARGS__)
 322 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 323 #define emberAfBinaryInputBasicClusterFlush()
 324 #define emberAfBinaryInputBasicClusterDebugExec(x)                                                                                 \
 325     if (emberAfPrintEnabled(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER))                                                            \
 326     {                                                                                                                              \
 327         x;                                                                                                                         \
 328     }
 329 #define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace)                                                          \
 330     emberAfPrintBuffer(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer), (len), (withSpace))
 331 #define emberAfBinaryInputBasicClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER, (buffer))
 332 #else
 333 #define emberAfBinaryInputBasicClusterPrint(...)
 334 #define emberAfBinaryInputBasicClusterPrintln(...)
 335 #define emberAfBinaryInputBasicClusterFlush()
 336 #define emberAfBinaryInputBasicClusterDebugExec(x)
 337 #define emberAfBinaryInputBasicClusterPrintBuffer(buffer, len, withSpace)
 338 #define emberAfBinaryInputBasicClusterPrintString(buffer)
 339 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BINARY_INPUT_BASIC_CLUSTER)
 340
 341 // Printing macros for cluster: Commissioning
 342 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER)
 343 #define emberAfCommissioningClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, __VA_ARGS__)
 344 #define emberAfCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, __VA_ARGS__)
 345 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 346 #define emberAfCommissioningClusterFlush()
 347 #define emberAfCommissioningClusterDebugExec(x)                                                                                    \
 348     if (emberAfPrintEnabled(EMBER_AF_PRINT_COMMISSIONING_CLUSTER))                                                                 \
 349     {                                                                                                                              \
 350         x;                                                                                                                         \
 351     }
 352 #define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace)                                                             \
 353     emberAfPrintBuffer(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace))
 354 #define emberAfCommissioningClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COMMISSIONING_CLUSTER, (buffer))
 355 #else
 356 #define emberAfCommissioningClusterPrint(...)
 357 #define emberAfCommissioningClusterPrintln(...)
 358 #define emberAfCommissioningClusterFlush()
 359 #define emberAfCommissioningClusterDebugExec(x)
 360 #define emberAfCommissioningClusterPrintBuffer(buffer, len, withSpace)
 361 #define emberAfCommissioningClusterPrintString(buffer)
 362 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COMMISSIONING_CLUSTER)
 363
 364 // Printing macros for cluster: Partition
 365 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER)
 366 #define emberAfPartitionClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PARTITION_CLUSTER, __VA_ARGS__)
 367 #define emberAfPartitionClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PARTITION_CLUSTER, __VA_ARGS__)
 368 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 369 #define emberAfPartitionClusterFlush()
 370 #define emberAfPartitionClusterDebugExec(x)                                                                                        \
 371     if (emberAfPrintEnabled(EMBER_AF_PRINT_PARTITION_CLUSTER))                                                                     \
 372     {                                                                                                                              \
 373         x;                                                                                                                         \
 374     }
 375 #define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace)                                                                 \
 376     emberAfPrintBuffer(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer), (len), (withSpace))
 377 #define emberAfPartitionClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PARTITION_CLUSTER, (buffer))
 378 #else
 379 #define emberAfPartitionClusterPrint(...)
 380 #define emberAfPartitionClusterPrintln(...)
 381 #define emberAfPartitionClusterFlush()
 382 #define emberAfPartitionClusterDebugExec(x)
 383 #define emberAfPartitionClusterPrintBuffer(buffer, len, withSpace)
 384 #define emberAfPartitionClusterPrintString(buffer)
 385 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PARTITION_CLUSTER)
 386
 387 // Printing macros for cluster: Over the Air Bootloading
 388 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER)
 389 #define emberAfOtaBootloadClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, __VA_ARGS__)
 390 #define emberAfOtaBootloadClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, __VA_ARGS__)
 391 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 392 #define emberAfOtaBootloadClusterFlush()
 393 #define emberAfOtaBootloadClusterDebugExec(x)                                                                                      \
 394     if (emberAfPrintEnabled(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER))                                                                  \
 395     {                                                                                                                              \
 396         x;                                                                                                                         \
 397     }
 398 #define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace)                                                               \
 399     emberAfPrintBuffer(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer), (len), (withSpace))
 400 #define emberAfOtaBootloadClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER, (buffer))
 401 #else
 402 #define emberAfOtaBootloadClusterPrint(...)
 403 #define emberAfOtaBootloadClusterPrintln(...)
 404 #define emberAfOtaBootloadClusterFlush()
 405 #define emberAfOtaBootloadClusterDebugExec(x)
 406 #define emberAfOtaBootloadClusterPrintBuffer(buffer, len, withSpace)
 407 #define emberAfOtaBootloadClusterPrintString(buffer)
 408 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_BOOTLOAD_CLUSTER)
 409
 410 // Printing macros for cluster: Power Profile
 411 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER)
 412 #define emberAfPowerProfileClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, __VA_ARGS__)
 413 #define emberAfPowerProfileClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, __VA_ARGS__)
 414 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 415 #define emberAfPowerProfileClusterFlush()
 416 #define emberAfPowerProfileClusterDebugExec(x)                                                                                     \
 417     if (emberAfPrintEnabled(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER))                                                                 \
 418     {                                                                                                                              \
 419         x;                                                                                                                         \
 420     }
 421 #define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace)                                                              \
 422     emberAfPrintBuffer(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer), (len), (withSpace))
 423 #define emberAfPowerProfileClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER, (buffer))
 424 #else
 425 #define emberAfPowerProfileClusterPrint(...)
 426 #define emberAfPowerProfileClusterPrintln(...)
 427 #define emberAfPowerProfileClusterFlush()
 428 #define emberAfPowerProfileClusterDebugExec(x)
 429 #define emberAfPowerProfileClusterPrintBuffer(buffer, len, withSpace)
 430 #define emberAfPowerProfileClusterPrintString(buffer)
 431 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POWER_PROFILE_CLUSTER)
 432
 433 // Printing macros for cluster: Appliance Control
 434 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER)
 435 #define emberAfApplianceControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, __VA_ARGS__)
 436 #define emberAfApplianceControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, __VA_ARGS__)
 437 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 438 #define emberAfApplianceControlClusterFlush()
 439 #define emberAfApplianceControlClusterDebugExec(x)                                                                                 \
 440     if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER))                                                             \
 441     {                                                                                                                              \
 442         x;                                                                                                                         \
 443     }
 444 #define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace)                                                          \
 445     emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 446 #define emberAfApplianceControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER, (buffer))
 447 #else
 448 #define emberAfApplianceControlClusterPrint(...)
 449 #define emberAfApplianceControlClusterPrintln(...)
 450 #define emberAfApplianceControlClusterFlush()
 451 #define emberAfApplianceControlClusterDebugExec(x)
 452 #define emberAfApplianceControlClusterPrintBuffer(buffer, len, withSpace)
 453 #define emberAfApplianceControlClusterPrintString(buffer)
 454 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_CONTROL_CLUSTER)
 455
 456 // Printing macros for cluster: Poll Control
 457 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER)
 458 #define emberAfPollControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, __VA_ARGS__)
 459 #define emberAfPollControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, __VA_ARGS__)
 460 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 461 #define emberAfPollControlClusterFlush()
 462 #define emberAfPollControlClusterDebugExec(x)                                                                                      \
 463     if (emberAfPrintEnabled(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER))                                                                  \
 464     {                                                                                                                              \
 465         x;                                                                                                                         \
 466     }
 467 #define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace)                                                               \
 468     emberAfPrintBuffer(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 469 #define emberAfPollControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER, (buffer))
 470 #else
 471 #define emberAfPollControlClusterPrint(...)
 472 #define emberAfPollControlClusterPrintln(...)
 473 #define emberAfPollControlClusterFlush()
 474 #define emberAfPollControlClusterDebugExec(x)
 475 #define emberAfPollControlClusterPrintBuffer(buffer, len, withSpace)
 476 #define emberAfPollControlClusterPrintString(buffer)
 477 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_POLL_CONTROL_CLUSTER)
 478
 479 // Printing macros for cluster: Green Power
 480 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER)
 481 #define emberAfGreenPowerClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, __VA_ARGS__)
 482 #define emberAfGreenPowerClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, __VA_ARGS__)
 483 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 484 #define emberAfGreenPowerClusterFlush()
 485 #define emberAfGreenPowerClusterDebugExec(x)                                                                                       \
 486     if (emberAfPrintEnabled(EMBER_AF_PRINT_GREEN_POWER_CLUSTER))                                                                   \
 487     {                                                                                                                              \
 488         x;                                                                                                                         \
 489     }
 490 #define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace)                                                                \
 491     emberAfPrintBuffer(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer), (len), (withSpace))
 492 #define emberAfGreenPowerClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GREEN_POWER_CLUSTER, (buffer))
 493 #else
 494 #define emberAfGreenPowerClusterPrint(...)
 495 #define emberAfGreenPowerClusterPrintln(...)
 496 #define emberAfGreenPowerClusterFlush()
 497 #define emberAfGreenPowerClusterDebugExec(x)
 498 #define emberAfGreenPowerClusterPrintBuffer(buffer, len, withSpace)
 499 #define emberAfGreenPowerClusterPrintString(buffer)
 500 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GREEN_POWER_CLUSTER)
 501
 502 // Printing macros for cluster: Keep-Alive
 503 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER)
 504 #define emberAfKeepaliveClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, __VA_ARGS__)
 505 #define emberAfKeepaliveClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, __VA_ARGS__)
 506 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 507 #define emberAfKeepaliveClusterFlush()
 508 #define emberAfKeepaliveClusterDebugExec(x)                                                                                        \
 509     if (emberAfPrintEnabled(EMBER_AF_PRINT_KEEPALIVE_CLUSTER))                                                                     \
 510     {                                                                                                                              \
 511         x;                                                                                                                         \
 512     }
 513 #define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace)                                                                 \
 514     emberAfPrintBuffer(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer), (len), (withSpace))
 515 #define emberAfKeepaliveClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_KEEPALIVE_CLUSTER, (buffer))
 516 #else
 517 #define emberAfKeepaliveClusterPrint(...)
 518 #define emberAfKeepaliveClusterPrintln(...)
 519 #define emberAfKeepaliveClusterFlush()
 520 #define emberAfKeepaliveClusterDebugExec(x)
 521 #define emberAfKeepaliveClusterPrintBuffer(buffer, len, withSpace)
 522 #define emberAfKeepaliveClusterPrintString(buffer)
 523 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEEPALIVE_CLUSTER)
 524
 525 // Printing macros for cluster: Shade Configuration
 526 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER)
 527 #define emberAfShadeConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, __VA_ARGS__)
 528 #define emberAfShadeConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, __VA_ARGS__)
 529 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 530 #define emberAfShadeConfigClusterFlush()
 531 #define emberAfShadeConfigClusterDebugExec(x)                                                                                      \
 532     if (emberAfPrintEnabled(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER))                                                                  \
 533     {                                                                                                                              \
 534         x;                                                                                                                         \
 535     }
 536 #define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace)                                                               \
 537     emberAfPrintBuffer(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer), (len), (withSpace))
 538 #define emberAfShadeConfigClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER, (buffer))
 539 #else
 540 #define emberAfShadeConfigClusterPrint(...)
 541 #define emberAfShadeConfigClusterPrintln(...)
 542 #define emberAfShadeConfigClusterFlush()
 543 #define emberAfShadeConfigClusterDebugExec(x)
 544 #define emberAfShadeConfigClusterPrintBuffer(buffer, len, withSpace)
 545 #define emberAfShadeConfigClusterPrintString(buffer)
 546 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SHADE_CONFIG_CLUSTER)
 547
 548 // Printing macros for cluster: Door Lock
 549 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER)
 550 #define emberAfDoorLockClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, __VA_ARGS__)
 551 #define emberAfDoorLockClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, __VA_ARGS__)
 552 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 553 #define emberAfDoorLockClusterFlush()
 554 #define emberAfDoorLockClusterDebugExec(x)                                                                                         \
 555     if (emberAfPrintEnabled(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER))                                                                     \
 556     {                                                                                                                              \
 557         x;                                                                                                                         \
 558     }
 559 #define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace)                                                                  \
 560     emberAfPrintBuffer(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer), (len), (withSpace))
 561 #define emberAfDoorLockClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER, (buffer))
 562 #else
 563 #define emberAfDoorLockClusterPrint(...)
 564 #define emberAfDoorLockClusterPrintln(...)
 565 #define emberAfDoorLockClusterFlush()
 566 #define emberAfDoorLockClusterDebugExec(x)
 567 #define emberAfDoorLockClusterPrintBuffer(buffer, len, withSpace)
 568 #define emberAfDoorLockClusterPrintString(buffer)
 569 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DOOR_LOCK_CLUSTER)
 570
 571 // Printing macros for cluster: Window Covering
 572 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER)
 573 #define emberAfWindowCoveringClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, __VA_ARGS__)
 574 #define emberAfWindowCoveringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, __VA_ARGS__)
 575 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 576 #define emberAfWindowCoveringClusterFlush()
 577 #define emberAfWindowCoveringClusterDebugExec(x)                                                                                   \
 578     if (emberAfPrintEnabled(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER))                                                               \
 579     {                                                                                                                              \
 580         x;                                                                                                                         \
 581     }
 582 #define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace)                                                            \
 583     emberAfPrintBuffer(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer), (len), (withSpace))
 584 #define emberAfWindowCoveringClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER, (buffer))
 585 #else
 586 #define emberAfWindowCoveringClusterPrint(...)
 587 #define emberAfWindowCoveringClusterPrintln(...)
 588 #define emberAfWindowCoveringClusterFlush()
 589 #define emberAfWindowCoveringClusterDebugExec(x)
 590 #define emberAfWindowCoveringClusterPrintBuffer(buffer, len, withSpace)
 591 #define emberAfWindowCoveringClusterPrintString(buffer)
 592 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_WINDOW_COVERING_CLUSTER)
 593
 594 // Printing macros for cluster: Barrier Control
 595 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER)
 596 #define emberAfBarrierControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, __VA_ARGS__)
 597 #define emberAfBarrierControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, __VA_ARGS__)
 598 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 599 #define emberAfBarrierControlClusterFlush()
 600 #define emberAfBarrierControlClusterDebugExec(x)                                                                                   \
 601     if (emberAfPrintEnabled(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER))                                                               \
 602     {                                                                                                                              \
 603         x;                                                                                                                         \
 604     }
 605 #define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace)                                                            \
 606     emberAfPrintBuffer(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 607 #define emberAfBarrierControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER, (buffer))
 608 #else
 609 #define emberAfBarrierControlClusterPrint(...)
 610 #define emberAfBarrierControlClusterPrintln(...)
 611 #define emberAfBarrierControlClusterFlush()
 612 #define emberAfBarrierControlClusterDebugExec(x)
 613 #define emberAfBarrierControlClusterPrintBuffer(buffer, len, withSpace)
 614 #define emberAfBarrierControlClusterPrintString(buffer)
 615 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BARRIER_CONTROL_CLUSTER)
 616
 617 // Printing macros for cluster: Pump Configuration and Control
 618 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER)
 619 #define emberAfPumpConfigControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, __VA_ARGS__)
 620 #define emberAfPumpConfigControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, __VA_ARGS__)
 621 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 622 #define emberAfPumpConfigControlClusterFlush()
 623 #define emberAfPumpConfigControlClusterDebugExec(x)                                                                                \
 624     if (emberAfPrintEnabled(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER))                                                           \
 625     {                                                                                                                              \
 626         x;                                                                                                                         \
 627     }
 628 #define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace)                                                         \
 629     emberAfPrintBuffer(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 630 #define emberAfPumpConfigControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER, (buffer))
 631 #else
 632 #define emberAfPumpConfigControlClusterPrint(...)
 633 #define emberAfPumpConfigControlClusterPrintln(...)
 634 #define emberAfPumpConfigControlClusterFlush()
 635 #define emberAfPumpConfigControlClusterDebugExec(x)
 636 #define emberAfPumpConfigControlClusterPrintBuffer(buffer, len, withSpace)
 637 #define emberAfPumpConfigControlClusterPrintString(buffer)
 638 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PUMP_CONFIG_CONTROL_CLUSTER)
 639
 640 // Printing macros for cluster: Thermostat
 641 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER)
 642 #define emberAfThermostatClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, __VA_ARGS__)
 643 #define emberAfThermostatClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, __VA_ARGS__)
 644 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 645 #define emberAfThermostatClusterFlush()
 646 #define emberAfThermostatClusterDebugExec(x)                                                                                       \
 647     if (emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_CLUSTER))                                                                    \
 648     {                                                                                                                              \
 649         x;                                                                                                                         \
 650     }
 651 #define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace)                                                                \
 652     emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer), (len), (withSpace))
 653 #define emberAfThermostatClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_CLUSTER, (buffer))
 654 #else
 655 #define emberAfThermostatClusterPrint(...)
 656 #define emberAfThermostatClusterPrintln(...)
 657 #define emberAfThermostatClusterFlush()
 658 #define emberAfThermostatClusterDebugExec(x)
 659 #define emberAfThermostatClusterPrintBuffer(buffer, len, withSpace)
 660 #define emberAfThermostatClusterPrintString(buffer)
 661 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_CLUSTER)
 662
 663 // Printing macros for cluster: Fan Control
 664 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER)
 665 #define emberAfFanControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, __VA_ARGS__)
 666 #define emberAfFanControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, __VA_ARGS__)
 667 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 668 #define emberAfFanControlClusterFlush()
 669 #define emberAfFanControlClusterDebugExec(x)                                                                                       \
 670     if (emberAfPrintEnabled(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER))                                                                   \
 671     {                                                                                                                              \
 672         x;                                                                                                                         \
 673     }
 674 #define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace)                                                                \
 675     emberAfPrintBuffer(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 676 #define emberAfFanControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER, (buffer))
 677 #else
 678 #define emberAfFanControlClusterPrint(...)
 679 #define emberAfFanControlClusterPrintln(...)
 680 #define emberAfFanControlClusterFlush()
 681 #define emberAfFanControlClusterDebugExec(x)
 682 #define emberAfFanControlClusterPrintBuffer(buffer, len, withSpace)
 683 #define emberAfFanControlClusterPrintString(buffer)
 684 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FAN_CONTROL_CLUSTER)
 685
 686 // Printing macros for cluster: Dehumidification Control
 687 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER)
 688 #define emberAfDehumidControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, __VA_ARGS__)
 689 #define emberAfDehumidControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, __VA_ARGS__)
 690 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 691 #define emberAfDehumidControlClusterFlush()
 692 #define emberAfDehumidControlClusterDebugExec(x)                                                                                   \
 693     if (emberAfPrintEnabled(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER))                                                               \
 694     {                                                                                                                              \
 695         x;                                                                                                                         \
 696     }
 697 #define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace)                                                            \
 698     emberAfPrintBuffer(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 699 #define emberAfDehumidControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER, (buffer))
 700 #else
 701 #define emberAfDehumidControlClusterPrint(...)
 702 #define emberAfDehumidControlClusterPrintln(...)
 703 #define emberAfDehumidControlClusterFlush()
 704 #define emberAfDehumidControlClusterDebugExec(x)
 705 #define emberAfDehumidControlClusterPrintBuffer(buffer, len, withSpace)
 706 #define emberAfDehumidControlClusterPrintString(buffer)
 707 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEHUMID_CONTROL_CLUSTER)
 708
 709 // Printing macros for cluster: Thermostat User Interface Configuration
 710 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER)
 711 #define emberAfThermostatUiConfigClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, __VA_ARGS__)
 712 #define emberAfThermostatUiConfigClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, __VA_ARGS__)
 713 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 714 #define emberAfThermostatUiConfigClusterFlush()
 715 #define emberAfThermostatUiConfigClusterDebugExec(x)                                                                               \
 716     if (emberAfPrintEnabled(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER))                                                          \
 717     {                                                                                                                              \
 718         x;                                                                                                                         \
 719     }
 720 #define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace)                                                        \
 721     emberAfPrintBuffer(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer), (len), (withSpace))
 722 #define emberAfThermostatUiConfigClusterPrintString(buffer)                                                                        \
 723     emberAfPrintString(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER, (buffer))
 724 #else
 725 #define emberAfThermostatUiConfigClusterPrint(...)
 726 #define emberAfThermostatUiConfigClusterPrintln(...)
 727 #define emberAfThermostatUiConfigClusterFlush()
 728 #define emberAfThermostatUiConfigClusterDebugExec(x)
 729 #define emberAfThermostatUiConfigClusterPrintBuffer(buffer, len, withSpace)
 730 #define emberAfThermostatUiConfigClusterPrintString(buffer)
 731 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_THERMOSTAT_UI_CONFIG_CLUSTER)
 732
 733 // Printing macros for cluster: Color Control
 734 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER)
 735 #define emberAfColorControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, __VA_ARGS__)
 736 #define emberAfColorControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, __VA_ARGS__)
 737 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 738 #define emberAfColorControlClusterFlush()
 739 #define emberAfColorControlClusterDebugExec(x)                                                                                     \
 740     if (emberAfPrintEnabled(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER))                                                                 \
 741     {                                                                                                                              \
 742         x;                                                                                                                         \
 743     }
 744 #define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace)                                                              \
 745     emberAfPrintBuffer(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer), (len), (withSpace))
 746 #define emberAfColorControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER, (buffer))
 747 #else
 748 #define emberAfColorControlClusterPrint(...)
 749 #define emberAfColorControlClusterPrintln(...)
 750 #define emberAfColorControlClusterFlush()
 751 #define emberAfColorControlClusterDebugExec(x)
 752 #define emberAfColorControlClusterPrintBuffer(buffer, len, withSpace)
 753 #define emberAfColorControlClusterPrintString(buffer)
 754 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COLOR_CONTROL_CLUSTER)
 755
 756 // Printing macros for cluster: Ballast Configuration
 757 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER)
 758 #define emberAfBallastConfigurationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, __VA_ARGS__)
 759 #define emberAfBallastConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, __VA_ARGS__)
 760 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 761 #define emberAfBallastConfigurationClusterFlush()
 762 #define emberAfBallastConfigurationClusterDebugExec(x)                                                                             \
 763     if (emberAfPrintEnabled(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER))                                                         \
 764     {                                                                                                                              \
 765         x;                                                                                                                         \
 766     }
 767 #define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace)                                                      \
 768     emberAfPrintBuffer(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace))
 769 #define emberAfBallastConfigurationClusterPrintString(buffer)                                                                      \
 770     emberAfPrintString(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER, (buffer))
 771 #else
 772 #define emberAfBallastConfigurationClusterPrint(...)
 773 #define emberAfBallastConfigurationClusterPrintln(...)
 774 #define emberAfBallastConfigurationClusterFlush()
 775 #define emberAfBallastConfigurationClusterDebugExec(x)
 776 #define emberAfBallastConfigurationClusterPrintBuffer(buffer, len, withSpace)
 777 #define emberAfBallastConfigurationClusterPrintString(buffer)
 778 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BALLAST_CONFIGURATION_CLUSTER)
 779
 780 // Printing macros for cluster: Illuminance Measurement
 781 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER)
 782 #define emberAfIllumMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, __VA_ARGS__)
 783 #define emberAfIllumMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, __VA_ARGS__)
 784 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 785 #define emberAfIllumMeasurementClusterFlush()
 786 #define emberAfIllumMeasurementClusterDebugExec(x)                                                                                 \
 787     if (emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER))                                                             \
 788     {                                                                                                                              \
 789         x;                                                                                                                         \
 790     }
 791 #define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace)                                                          \
 792     emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 793 #define emberAfIllumMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER, (buffer))
 794 #else
 795 #define emberAfIllumMeasurementClusterPrint(...)
 796 #define emberAfIllumMeasurementClusterPrintln(...)
 797 #define emberAfIllumMeasurementClusterFlush()
 798 #define emberAfIllumMeasurementClusterDebugExec(x)
 799 #define emberAfIllumMeasurementClusterPrintBuffer(buffer, len, withSpace)
 800 #define emberAfIllumMeasurementClusterPrintString(buffer)
 801 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_MEASUREMENT_CLUSTER)
 802
 803 // Printing macros for cluster: Illuminance Level Sensing
 804 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER)
 805 #define emberAfIllumLevelSensingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, __VA_ARGS__)
 806 #define emberAfIllumLevelSensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, __VA_ARGS__)
 807 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 808 #define emberAfIllumLevelSensingClusterFlush()
 809 #define emberAfIllumLevelSensingClusterDebugExec(x)                                                                                \
 810     if (emberAfPrintEnabled(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER))                                                           \
 811     {                                                                                                                              \
 812         x;                                                                                                                         \
 813     }
 814 #define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace)                                                         \
 815     emberAfPrintBuffer(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer), (len), (withSpace))
 816 #define emberAfIllumLevelSensingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER, (buffer))
 817 #else
 818 #define emberAfIllumLevelSensingClusterPrint(...)
 819 #define emberAfIllumLevelSensingClusterPrintln(...)
 820 #define emberAfIllumLevelSensingClusterFlush()
 821 #define emberAfIllumLevelSensingClusterDebugExec(x)
 822 #define emberAfIllumLevelSensingClusterPrintBuffer(buffer, len, withSpace)
 823 #define emberAfIllumLevelSensingClusterPrintString(buffer)
 824 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ILLUM_LEVEL_SENSING_CLUSTER)
 825
 826 // Printing macros for cluster: Temperature Measurement
 827 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER)
 828 #define emberAfTempMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, __VA_ARGS__)
 829 #define emberAfTempMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, __VA_ARGS__)
 830 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 831 #define emberAfTempMeasurementClusterFlush()
 832 #define emberAfTempMeasurementClusterDebugExec(x)                                                                                  \
 833     if (emberAfPrintEnabled(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER))                                                              \
 834     {                                                                                                                              \
 835         x;                                                                                                                         \
 836     }
 837 #define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace)                                                           \
 838     emberAfPrintBuffer(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 839 #define emberAfTempMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER, (buffer))
 840 #else
 841 #define emberAfTempMeasurementClusterPrint(...)
 842 #define emberAfTempMeasurementClusterPrintln(...)
 843 #define emberAfTempMeasurementClusterFlush()
 844 #define emberAfTempMeasurementClusterDebugExec(x)
 845 #define emberAfTempMeasurementClusterPrintBuffer(buffer, len, withSpace)
 846 #define emberAfTempMeasurementClusterPrintString(buffer)
 847 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TEMP_MEASUREMENT_CLUSTER)
 848
 849 // Printing macros for cluster: Pressure Measurement
 850 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER)
 851 #define emberAfPressureMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, __VA_ARGS__)
 852 #define emberAfPressureMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, __VA_ARGS__)
 853 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 854 #define emberAfPressureMeasurementClusterFlush()
 855 #define emberAfPressureMeasurementClusterDebugExec(x)                                                                              \
 856     if (emberAfPrintEnabled(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER))                                                          \
 857     {                                                                                                                              \
 858         x;                                                                                                                         \
 859     }
 860 #define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace)                                                       \
 861     emberAfPrintBuffer(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 862 #define emberAfPressureMeasurementClusterPrintString(buffer)                                                                       \
 863     emberAfPrintString(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER, (buffer))
 864 #else
 865 #define emberAfPressureMeasurementClusterPrint(...)
 866 #define emberAfPressureMeasurementClusterPrintln(...)
 867 #define emberAfPressureMeasurementClusterFlush()
 868 #define emberAfPressureMeasurementClusterDebugExec(x)
 869 #define emberAfPressureMeasurementClusterPrintBuffer(buffer, len, withSpace)
 870 #define emberAfPressureMeasurementClusterPrintString(buffer)
 871 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRESSURE_MEASUREMENT_CLUSTER)
 872
 873 // Printing macros for cluster: Flow Measurement
 874 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER)
 875 #define emberAfFlowMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, __VA_ARGS__)
 876 #define emberAfFlowMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, __VA_ARGS__)
 877 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 878 #define emberAfFlowMeasurementClusterFlush()
 879 #define emberAfFlowMeasurementClusterDebugExec(x)                                                                                  \
 880     if (emberAfPrintEnabled(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER))                                                              \
 881     {                                                                                                                              \
 882         x;                                                                                                                         \
 883     }
 884 #define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace)                                                           \
 885     emberAfPrintBuffer(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 886 #define emberAfFlowMeasurementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER, (buffer))
 887 #else
 888 #define emberAfFlowMeasurementClusterPrint(...)
 889 #define emberAfFlowMeasurementClusterPrintln(...)
 890 #define emberAfFlowMeasurementClusterFlush()
 891 #define emberAfFlowMeasurementClusterDebugExec(x)
 892 #define emberAfFlowMeasurementClusterPrintBuffer(buffer, len, withSpace)
 893 #define emberAfFlowMeasurementClusterPrintString(buffer)
 894 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLOW_MEASUREMENT_CLUSTER)
 895
 896 // Printing macros for cluster: Relative Humidity Measurement
 897 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER)
 898 #define emberAfRelativeHumidityMeasurementClusterPrint(...)                                                                        \
 899     emberAfPrint(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__)
 900 #define emberAfRelativeHumidityMeasurementClusterPrintln(...)                                                                      \
 901     emberAfPrintln(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, __VA_ARGS__)
 902 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 903 #define emberAfRelativeHumidityMeasurementClusterFlush()
 904 #define emberAfRelativeHumidityMeasurementClusterDebugExec(x)                                                                      \
 905     if (emberAfPrintEnabled(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER))                                                 \
 906     {                                                                                                                              \
 907         x;                                                                                                                         \
 908     }
 909 #define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace)                                               \
 910     emberAfPrintBuffer(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 911 #define emberAfRelativeHumidityMeasurementClusterPrintString(buffer)                                                               \
 912     emberAfPrintString(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER, (buffer))
 913 #else
 914 #define emberAfRelativeHumidityMeasurementClusterPrint(...)
 915 #define emberAfRelativeHumidityMeasurementClusterPrintln(...)
 916 #define emberAfRelativeHumidityMeasurementClusterFlush()
 917 #define emberAfRelativeHumidityMeasurementClusterDebugExec(x)
 918 #define emberAfRelativeHumidityMeasurementClusterPrintBuffer(buffer, len, withSpace)
 919 #define emberAfRelativeHumidityMeasurementClusterPrintString(buffer)
 920 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER)
 921
 922 // Printing macros for cluster: Occupancy Sensing
 923 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER)
 924 #define emberAfOccupancySensingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, __VA_ARGS__)
 925 #define emberAfOccupancySensingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, __VA_ARGS__)
 926 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 927 #define emberAfOccupancySensingClusterFlush()
 928 #define emberAfOccupancySensingClusterDebugExec(x)                                                                                 \
 929     if (emberAfPrintEnabled(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER))                                                             \
 930     {                                                                                                                              \
 931         x;                                                                                                                         \
 932     }
 933 #define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace)                                                          \
 934     emberAfPrintBuffer(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer), (len), (withSpace))
 935 #define emberAfOccupancySensingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER, (buffer))
 936 #else
 937 #define emberAfOccupancySensingClusterPrint(...)
 938 #define emberAfOccupancySensingClusterPrintln(...)
 939 #define emberAfOccupancySensingClusterFlush()
 940 #define emberAfOccupancySensingClusterDebugExec(x)
 941 #define emberAfOccupancySensingClusterPrintBuffer(buffer, len, withSpace)
 942 #define emberAfOccupancySensingClusterPrintString(buffer)
 943 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OCCUPANCY_SENSING_CLUSTER)
 944
 945 // Printing macros for cluster: Carbon Monoxide Concentration Measurement
 946 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 947 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...)                                                             \
 948     emberAfPrint(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 949 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...)                                                           \
 950     emberAfPrintln(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 951 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 952 #define emberAfCarbonMonoxideConcentrationMeasurementClusterFlush()
 953 #define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x)                                                           \
 954     if (emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                     \
 955     {                                                                                                                              \
 956         x;                                                                                                                         \
 957     }
 958 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                    \
 959     emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 960 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer)                                                    \
 961     emberAfPrintString(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 962 #else
 963 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrint(...)
 964 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintln(...)
 965 #define emberAfCarbonMonoxideConcentrationMeasurementClusterFlush()
 966 #define emberAfCarbonMonoxideConcentrationMeasurementClusterDebugExec(x)
 967 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 968 #define emberAfCarbonMonoxideConcentrationMeasurementClusterPrintString(buffer)
 969 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 970
 971 // Printing macros for cluster: Carbon Dioxide Concentration Measurement
 972 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 973 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...)                                                              \
 974     emberAfPrint(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 975 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...)                                                            \
 976     emberAfPrintln(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
 977 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
 978 #define emberAfCarbonDioxideConcentrationMeasurementClusterFlush()
 979 #define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x)                                                            \
 980     if (emberAfPrintEnabled(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                      \
 981     {                                                                                                                              \
 982         x;                                                                                                                         \
 983     }
 984 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                     \
 985     emberAfPrintBuffer(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
 986 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer)                                                     \
 987     emberAfPrintString(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
 988 #else
 989 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrint(...)
 990 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintln(...)
 991 #define emberAfCarbonDioxideConcentrationMeasurementClusterFlush()
 992 #define emberAfCarbonDioxideConcentrationMeasurementClusterDebugExec(x)
 993 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
 994 #define emberAfCarbonDioxideConcentrationMeasurementClusterPrintString(buffer)
 995 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
 996
 997 // Printing macros for cluster: Ethylene Concentration Measurement
 998 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER)
 999 #define emberAfEthyleneConcentrationMeasurementClusterPrint(...)                                                                   \
1000     emberAfPrint(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1001 #define emberAfEthyleneConcentrationMeasurementClusterPrintln(...)                                                                 \
1002     emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1003 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1004 #define emberAfEthyleneConcentrationMeasurementClusterFlush()
1005 #define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x)                                                                 \
1006     if (emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER))                                            \
1007     {                                                                                                                              \
1008         x;                                                                                                                         \
1009     }
1010 #define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                          \
1011     emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1012 #define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer)                                                          \
1013     emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1014 #else
1015 #define emberAfEthyleneConcentrationMeasurementClusterPrint(...)
1016 #define emberAfEthyleneConcentrationMeasurementClusterPrintln(...)
1017 #define emberAfEthyleneConcentrationMeasurementClusterFlush()
1018 #define emberAfEthyleneConcentrationMeasurementClusterDebugExec(x)
1019 #define emberAfEthyleneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1020 #define emberAfEthyleneConcentrationMeasurementClusterPrintString(buffer)
1021 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER)
1022
1023 // Printing macros for cluster: Ethylene Oxide Concentration Measurement
1024 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1025 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...)                                                              \
1026     emberAfPrint(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1027 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...)                                                            \
1028     emberAfPrintln(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1029 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1030 #define emberAfEthyleneOxideConcentrationMeasurementClusterFlush()
1031 #define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x)                                                            \
1032     if (emberAfPrintEnabled(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                      \
1033     {                                                                                                                              \
1034         x;                                                                                                                         \
1035     }
1036 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                     \
1037     emberAfPrintBuffer(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1038 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer)                                                     \
1039     emberAfPrintString(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1040 #else
1041 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrint(...)
1042 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintln(...)
1043 #define emberAfEthyleneOxideConcentrationMeasurementClusterFlush()
1044 #define emberAfEthyleneOxideConcentrationMeasurementClusterDebugExec(x)
1045 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1046 #define emberAfEthyleneOxideConcentrationMeasurementClusterPrintString(buffer)
1047 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1048
1049 // Printing macros for cluster: Hydrogen Concentration Measurement
1050 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
1051 #define emberAfHydrogenConcentrationMeasurementClusterPrint(...)                                                                   \
1052     emberAfPrint(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1053 #define emberAfHydrogenConcentrationMeasurementClusterPrintln(...)                                                                 \
1054     emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1055 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1056 #define emberAfHydrogenConcentrationMeasurementClusterFlush()
1057 #define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x)                                                                 \
1058     if (emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER))                                            \
1059     {                                                                                                                              \
1060         x;                                                                                                                         \
1061     }
1062 #define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                          \
1063     emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1064 #define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer)                                                          \
1065     emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1066 #else
1067 #define emberAfHydrogenConcentrationMeasurementClusterPrint(...)
1068 #define emberAfHydrogenConcentrationMeasurementClusterPrintln(...)
1069 #define emberAfHydrogenConcentrationMeasurementClusterFlush()
1070 #define emberAfHydrogenConcentrationMeasurementClusterDebugExec(x)
1071 #define emberAfHydrogenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1072 #define emberAfHydrogenConcentrationMeasurementClusterPrintString(buffer)
1073 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
1074
1075 // Printing macros for cluster: Hydrogen Sulphide Concentration Measurement
1076 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1077 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...)                                                           \
1078     emberAfPrint(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1079 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...)                                                         \
1080     emberAfPrintln(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1081 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1082 #define emberAfHydrogenSulphideConcentrationMeasurementClusterFlush()
1083 #define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x)                                                         \
1084     if (emberAfPrintEnabled(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                   \
1085     {                                                                                                                              \
1086         x;                                                                                                                         \
1087     }
1088 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                  \
1089     emberAfPrintBuffer(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1090 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer)                                                  \
1091     emberAfPrintString(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1092 #else
1093 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrint(...)
1094 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintln(...)
1095 #define emberAfHydrogenSulphideConcentrationMeasurementClusterFlush()
1096 #define emberAfHydrogenSulphideConcentrationMeasurementClusterDebugExec(x)
1097 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1098 #define emberAfHydrogenSulphideConcentrationMeasurementClusterPrintString(buffer)
1099 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HYDROGEN_SULPHIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1100
1101 // Printing macros for cluster: Nitric Oxide Concentration Measurement
1102 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1103 #define emberAfNitricOxideConcentrationMeasurementClusterPrint(...)                                                                \
1104     emberAfPrint(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1105 #define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...)                                                              \
1106     emberAfPrintln(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1107 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1108 #define emberAfNitricOxideConcentrationMeasurementClusterFlush()
1109 #define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x)                                                              \
1110     if (emberAfPrintEnabled(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                        \
1111     {                                                                                                                              \
1112         x;                                                                                                                         \
1113     }
1114 #define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                       \
1115     emberAfPrintBuffer(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1116 #define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer)                                                       \
1117     emberAfPrintString(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1118 #else
1119 #define emberAfNitricOxideConcentrationMeasurementClusterPrint(...)
1120 #define emberAfNitricOxideConcentrationMeasurementClusterPrintln(...)
1121 #define emberAfNitricOxideConcentrationMeasurementClusterFlush()
1122 #define emberAfNitricOxideConcentrationMeasurementClusterDebugExec(x)
1123 #define emberAfNitricOxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1124 #define emberAfNitricOxideConcentrationMeasurementClusterPrintString(buffer)
1125 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1126
1127 // Printing macros for cluster: Nitrogen Dioxide Concentration Measurement
1128 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1129 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...)                                                            \
1130     emberAfPrint(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1131 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...)                                                          \
1132     emberAfPrintln(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1133 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1134 #define emberAfNitrogenDioxideConcentrationMeasurementClusterFlush()
1135 #define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x)                                                          \
1136     if (emberAfPrintEnabled(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                    \
1137     {                                                                                                                              \
1138         x;                                                                                                                         \
1139     }
1140 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                   \
1141     emberAfPrintBuffer(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1142 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer)                                                   \
1143     emberAfPrintString(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1144 #else
1145 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrint(...)
1146 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintln(...)
1147 #define emberAfNitrogenDioxideConcentrationMeasurementClusterFlush()
1148 #define emberAfNitrogenDioxideConcentrationMeasurementClusterDebugExec(x)
1149 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1150 #define emberAfNitrogenDioxideConcentrationMeasurementClusterPrintString(buffer)
1151 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1152
1153 // Printing macros for cluster: Oxygen Concentration Measurement
1154 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
1155 #define emberAfOxygenConcentrationMeasurementClusterPrint(...)                                                                     \
1156     emberAfPrint(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1157 #define emberAfOxygenConcentrationMeasurementClusterPrintln(...)                                                                   \
1158     emberAfPrintln(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1159 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1160 #define emberAfOxygenConcentrationMeasurementClusterFlush()
1161 #define emberAfOxygenConcentrationMeasurementClusterDebugExec(x)                                                                   \
1162     if (emberAfPrintEnabled(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER))                                              \
1163     {                                                                                                                              \
1164         x;                                                                                                                         \
1165     }
1166 #define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                            \
1167     emberAfPrintBuffer(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1168 #define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer)                                                            \
1169     emberAfPrintString(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1170 #else
1171 #define emberAfOxygenConcentrationMeasurementClusterPrint(...)
1172 #define emberAfOxygenConcentrationMeasurementClusterPrintln(...)
1173 #define emberAfOxygenConcentrationMeasurementClusterFlush()
1174 #define emberAfOxygenConcentrationMeasurementClusterDebugExec(x)
1175 #define emberAfOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1176 #define emberAfOxygenConcentrationMeasurementClusterPrintString(buffer)
1177 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
1178
1179 // Printing macros for cluster: Ozone Concentration Measurement
1180 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER)
1181 #define emberAfOzoneConcentrationMeasurementClusterPrint(...)                                                                      \
1182     emberAfPrint(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1183 #define emberAfOzoneConcentrationMeasurementClusterPrintln(...)                                                                    \
1184     emberAfPrintln(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1185 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1186 #define emberAfOzoneConcentrationMeasurementClusterFlush()
1187 #define emberAfOzoneConcentrationMeasurementClusterDebugExec(x)                                                                    \
1188     if (emberAfPrintEnabled(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER))                                               \
1189     {                                                                                                                              \
1190         x;                                                                                                                         \
1191     }
1192 #define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                             \
1193     emberAfPrintBuffer(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1194 #define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer)                                                             \
1195     emberAfPrintString(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1196 #else
1197 #define emberAfOzoneConcentrationMeasurementClusterPrint(...)
1198 #define emberAfOzoneConcentrationMeasurementClusterPrintln(...)
1199 #define emberAfOzoneConcentrationMeasurementClusterFlush()
1200 #define emberAfOzoneConcentrationMeasurementClusterDebugExec(x)
1201 #define emberAfOzoneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1202 #define emberAfOzoneConcentrationMeasurementClusterPrintString(buffer)
1203 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OZONE_CONCENTRATION_MEASUREMENT_CLUSTER)
1204
1205 // Printing macros for cluster: Sulfur Dioxide Concentration Measurement
1206 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1207 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...)                                                              \
1208     emberAfPrint(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1209 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...)                                                            \
1210     emberAfPrintln(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1211 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1212 #define emberAfSulfurDioxideConcentrationMeasurementClusterFlush()
1213 #define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x)                                                            \
1214     if (emberAfPrintEnabled(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                      \
1215     {                                                                                                                              \
1216         x;                                                                                                                         \
1217     }
1218 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                     \
1219     emberAfPrintBuffer(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1220 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer)                                                     \
1221     emberAfPrintString(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1222 #else
1223 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrint(...)
1224 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintln(...)
1225 #define emberAfSulfurDioxideConcentrationMeasurementClusterFlush()
1226 #define emberAfSulfurDioxideConcentrationMeasurementClusterDebugExec(x)
1227 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1228 #define emberAfSulfurDioxideConcentrationMeasurementClusterPrintString(buffer)
1229 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1230
1231 // Printing macros for cluster: Dissolved Oxygen Concentration Measurement
1232 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
1233 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...)                                                            \
1234     emberAfPrint(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1235 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...)                                                          \
1236     emberAfPrintln(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1237 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1238 #define emberAfDissolvedOxygenConcentrationMeasurementClusterFlush()
1239 #define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x)                                                          \
1240     if (emberAfPrintEnabled(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER))                                    \
1241     {                                                                                                                              \
1242         x;                                                                                                                         \
1243     }
1244 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                   \
1245     emberAfPrintBuffer(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1246 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer)                                                   \
1247     emberAfPrintString(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1248 #else
1249 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrint(...)
1250 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintln(...)
1251 #define emberAfDissolvedOxygenConcentrationMeasurementClusterFlush()
1252 #define emberAfDissolvedOxygenConcentrationMeasurementClusterDebugExec(x)
1253 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1254 #define emberAfDissolvedOxygenConcentrationMeasurementClusterPrintString(buffer)
1255 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER)
1256
1257 // Printing macros for cluster: Bromate Concentration Measurement
1258 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER)
1259 #define emberAfBromateConcentrationMeasurementClusterPrint(...)                                                                    \
1260     emberAfPrint(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1261 #define emberAfBromateConcentrationMeasurementClusterPrintln(...)                                                                  \
1262     emberAfPrintln(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1263 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1264 #define emberAfBromateConcentrationMeasurementClusterFlush()
1265 #define emberAfBromateConcentrationMeasurementClusterDebugExec(x)                                                                  \
1266     if (emberAfPrintEnabled(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER))                                             \
1267     {                                                                                                                              \
1268         x;                                                                                                                         \
1269     }
1270 #define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                           \
1271     emberAfPrintBuffer(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1272 #define emberAfBromateConcentrationMeasurementClusterPrintString(buffer)                                                           \
1273     emberAfPrintString(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1274 #else
1275 #define emberAfBromateConcentrationMeasurementClusterPrint(...)
1276 #define emberAfBromateConcentrationMeasurementClusterPrintln(...)
1277 #define emberAfBromateConcentrationMeasurementClusterFlush()
1278 #define emberAfBromateConcentrationMeasurementClusterDebugExec(x)
1279 #define emberAfBromateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1280 #define emberAfBromateConcentrationMeasurementClusterPrintString(buffer)
1281 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMATE_CONCENTRATION_MEASUREMENT_CLUSTER)
1282
1283 // Printing macros for cluster: Chloramines Concentration Measurement
1284 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER)
1285 #define emberAfChloraminesConcentrationMeasurementClusterPrint(...)                                                                \
1286     emberAfPrint(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1287 #define emberAfChloraminesConcentrationMeasurementClusterPrintln(...)                                                              \
1288     emberAfPrintln(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1289 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1290 #define emberAfChloraminesConcentrationMeasurementClusterFlush()
1291 #define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x)                                                              \
1292     if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER))                                         \
1293     {                                                                                                                              \
1294         x;                                                                                                                         \
1295     }
1296 #define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                       \
1297     emberAfPrintBuffer(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1298 #define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer)                                                       \
1299     emberAfPrintString(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1300 #else
1301 #define emberAfChloraminesConcentrationMeasurementClusterPrint(...)
1302 #define emberAfChloraminesConcentrationMeasurementClusterPrintln(...)
1303 #define emberAfChloraminesConcentrationMeasurementClusterFlush()
1304 #define emberAfChloraminesConcentrationMeasurementClusterDebugExec(x)
1305 #define emberAfChloraminesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1306 #define emberAfChloraminesConcentrationMeasurementClusterPrintString(buffer)
1307 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER)
1308
1309 // Printing macros for cluster: Chlorine Concentration Measurement
1310 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER)
1311 #define emberAfChlorineConcentrationMeasurementClusterPrint(...)                                                                   \
1312     emberAfPrint(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1313 #define emberAfChlorineConcentrationMeasurementClusterPrintln(...)                                                                 \
1314     emberAfPrintln(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1315 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1316 #define emberAfChlorineConcentrationMeasurementClusterFlush()
1317 #define emberAfChlorineConcentrationMeasurementClusterDebugExec(x)                                                                 \
1318     if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER))                                            \
1319     {                                                                                                                              \
1320         x;                                                                                                                         \
1321     }
1322 #define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                          \
1323     emberAfPrintBuffer(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1324 #define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer)                                                          \
1325     emberAfPrintString(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1326 #else
1327 #define emberAfChlorineConcentrationMeasurementClusterPrint(...)
1328 #define emberAfChlorineConcentrationMeasurementClusterPrintln(...)
1329 #define emberAfChlorineConcentrationMeasurementClusterFlush()
1330 #define emberAfChlorineConcentrationMeasurementClusterDebugExec(x)
1331 #define emberAfChlorineConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1332 #define emberAfChlorineConcentrationMeasurementClusterPrintString(buffer)
1333 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER)
1334
1335 // Printing macros for cluster: Fecal coliform and E. Coli Concentration Measurement
1336 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER)
1337 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...)                                                      \
1338     emberAfPrint(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1339 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...)                                                    \
1340     emberAfPrintln(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1341 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1342 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterFlush()
1343 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x)                                                    \
1344     if (emberAfPrintEnabled(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER))                           \
1345     {                                                                                                                              \
1346         x;                                                                                                                         \
1347     }
1348 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                             \
1349     emberAfPrintBuffer(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1350 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer)                                             \
1351     emberAfPrintString(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1352 #else
1353 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrint(...)
1354 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintln(...)
1355 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterFlush()
1356 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterDebugExec(x)
1357 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1358 #define emberAfFecalColiformAndEColiConcentrationMeasurementClusterPrintString(buffer)
1359 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FECAL_COLIFORM_AND_E_COLI_CONCENTRATION_MEASUREMENT_CLUSTER)
1360
1361 // Printing macros for cluster: Fluoride Concentration Measurement
1362 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1363 #define emberAfFluorideConcentrationMeasurementClusterPrint(...)                                                                   \
1364     emberAfPrint(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1365 #define emberAfFluorideConcentrationMeasurementClusterPrintln(...)                                                                 \
1366     emberAfPrintln(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1367 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1368 #define emberAfFluorideConcentrationMeasurementClusterFlush()
1369 #define emberAfFluorideConcentrationMeasurementClusterDebugExec(x)                                                                 \
1370     if (emberAfPrintEnabled(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER))                                            \
1371     {                                                                                                                              \
1372         x;                                                                                                                         \
1373     }
1374 #define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                          \
1375     emberAfPrintBuffer(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1376 #define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer)                                                          \
1377     emberAfPrintString(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1378 #else
1379 #define emberAfFluorideConcentrationMeasurementClusterPrint(...)
1380 #define emberAfFluorideConcentrationMeasurementClusterPrintln(...)
1381 #define emberAfFluorideConcentrationMeasurementClusterFlush()
1382 #define emberAfFluorideConcentrationMeasurementClusterDebugExec(x)
1383 #define emberAfFluorideConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1384 #define emberAfFluorideConcentrationMeasurementClusterPrintString(buffer)
1385 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER)
1386
1387 // Printing macros for cluster: Haloacetic Acids Concentration Measurement
1388 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER)
1389 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...)                                                            \
1390     emberAfPrint(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1391 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...)                                                          \
1392     emberAfPrintln(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1393 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1394 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterFlush()
1395 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x)                                                          \
1396     if (emberAfPrintEnabled(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER))                                    \
1397     {                                                                                                                              \
1398         x;                                                                                                                         \
1399     }
1400 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                   \
1401     emberAfPrintBuffer(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1402 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer)                                                   \
1403     emberAfPrintString(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1404 #else
1405 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrint(...)
1406 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintln(...)
1407 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterFlush()
1408 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterDebugExec(x)
1409 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1410 #define emberAfHaloaceticAcidsConcentrationMeasurementClusterPrintString(buffer)
1411 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER)
1412
1413 // Printing macros for cluster: Total Trihalomethanes Concentration Measurement
1414 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER)
1415 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...)                                                       \
1416     emberAfPrint(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1417 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...)                                                     \
1418     emberAfPrintln(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1419 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1420 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterFlush()
1421 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x)                                                     \
1422     if (emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER))                               \
1423     {                                                                                                                              \
1424         x;                                                                                                                         \
1425     }
1426 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                              \
1427     emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1428 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer)                                              \
1429     emberAfPrintString(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1430 #else
1431 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrint(...)
1432 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintln(...)
1433 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterFlush()
1434 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterDebugExec(x)
1435 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1436 #define emberAfTotalTrihalomethanesConcentrationMeasurementClusterPrintString(buffer)
1437 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_TRIHALOMETHANES_CONCENTRATION_MEASUREMENT_CLUSTER)
1438
1439 // Printing macros for cluster: Total Coliform Bacteria Concentration Measurement
1440 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER)
1441 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...)                                                      \
1442     emberAfPrint(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1443 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...)                                                    \
1444     emberAfPrintln(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1445 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1446 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterFlush()
1447 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x)                                                    \
1448     if (emberAfPrintEnabled(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER))                             \
1449     {                                                                                                                              \
1450         x;                                                                                                                         \
1451     }
1452 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                             \
1453     emberAfPrintBuffer(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1454 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer)                                             \
1455     emberAfPrintString(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1456 #else
1457 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrint(...)
1458 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintln(...)
1459 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterFlush()
1460 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterDebugExec(x)
1461 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1462 #define emberAfTotalColiformBacteriaConcentrationMeasurementClusterPrintString(buffer)
1463 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER)
1464
1465 // Printing macros for cluster: Turbidity Concentration Measurement
1466 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER)
1467 #define emberAfTurbidityConcentrationMeasurementClusterPrint(...)                                                                  \
1468     emberAfPrint(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1469 #define emberAfTurbidityConcentrationMeasurementClusterPrintln(...)                                                                \
1470     emberAfPrintln(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1471 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1472 #define emberAfTurbidityConcentrationMeasurementClusterFlush()
1473 #define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x)                                                                \
1474     if (emberAfPrintEnabled(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER))                                           \
1475     {                                                                                                                              \
1476         x;                                                                                                                         \
1477     }
1478 #define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                         \
1479     emberAfPrintBuffer(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1480 #define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer)                                                         \
1481     emberAfPrintString(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1482 #else
1483 #define emberAfTurbidityConcentrationMeasurementClusterPrint(...)
1484 #define emberAfTurbidityConcentrationMeasurementClusterPrintln(...)
1485 #define emberAfTurbidityConcentrationMeasurementClusterFlush()
1486 #define emberAfTurbidityConcentrationMeasurementClusterDebugExec(x)
1487 #define emberAfTurbidityConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1488 #define emberAfTurbidityConcentrationMeasurementClusterPrintString(buffer)
1489 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER)
1490
1491 // Printing macros for cluster: Copper Concentration Measurement
1492 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER)
1493 #define emberAfCopperConcentrationMeasurementClusterPrint(...)                                                                     \
1494     emberAfPrint(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1495 #define emberAfCopperConcentrationMeasurementClusterPrintln(...)                                                                   \
1496     emberAfPrintln(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1497 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1498 #define emberAfCopperConcentrationMeasurementClusterFlush()
1499 #define emberAfCopperConcentrationMeasurementClusterDebugExec(x)                                                                   \
1500     if (emberAfPrintEnabled(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER))                                              \
1501     {                                                                                                                              \
1502         x;                                                                                                                         \
1503     }
1504 #define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                            \
1505     emberAfPrintBuffer(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1506 #define emberAfCopperConcentrationMeasurementClusterPrintString(buffer)                                                            \
1507     emberAfPrintString(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1508 #else
1509 #define emberAfCopperConcentrationMeasurementClusterPrint(...)
1510 #define emberAfCopperConcentrationMeasurementClusterPrintln(...)
1511 #define emberAfCopperConcentrationMeasurementClusterFlush()
1512 #define emberAfCopperConcentrationMeasurementClusterDebugExec(x)
1513 #define emberAfCopperConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1514 #define emberAfCopperConcentrationMeasurementClusterPrintString(buffer)
1515 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_COPPER_CONCENTRATION_MEASUREMENT_CLUSTER)
1516
1517 // Printing macros for cluster: Lead Concentration Measurement
1518 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER)
1519 #define emberAfLeadConcentrationMeasurementClusterPrint(...)                                                                       \
1520     emberAfPrint(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1521 #define emberAfLeadConcentrationMeasurementClusterPrintln(...)                                                                     \
1522     emberAfPrintln(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1523 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1524 #define emberAfLeadConcentrationMeasurementClusterFlush()
1525 #define emberAfLeadConcentrationMeasurementClusterDebugExec(x)                                                                     \
1526     if (emberAfPrintEnabled(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER))                                                \
1527     {                                                                                                                              \
1528         x;                                                                                                                         \
1529     }
1530 #define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                              \
1531     emberAfPrintBuffer(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1532 #define emberAfLeadConcentrationMeasurementClusterPrintString(buffer)                                                              \
1533     emberAfPrintString(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1534 #else
1535 #define emberAfLeadConcentrationMeasurementClusterPrint(...)
1536 #define emberAfLeadConcentrationMeasurementClusterPrintln(...)
1537 #define emberAfLeadConcentrationMeasurementClusterFlush()
1538 #define emberAfLeadConcentrationMeasurementClusterDebugExec(x)
1539 #define emberAfLeadConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1540 #define emberAfLeadConcentrationMeasurementClusterPrintString(buffer)
1541 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_LEAD_CONCENTRATION_MEASUREMENT_CLUSTER)
1542
1543 // Printing macros for cluster: Manganese Concentration Measurement
1544 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER)
1545 #define emberAfManganeseConcentrationMeasurementClusterPrint(...)                                                                  \
1546     emberAfPrint(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1547 #define emberAfManganeseConcentrationMeasurementClusterPrintln(...)                                                                \
1548     emberAfPrintln(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1549 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1550 #define emberAfManganeseConcentrationMeasurementClusterFlush()
1551 #define emberAfManganeseConcentrationMeasurementClusterDebugExec(x)                                                                \
1552     if (emberAfPrintEnabled(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER))                                           \
1553     {                                                                                                                              \
1554         x;                                                                                                                         \
1555     }
1556 #define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                         \
1557     emberAfPrintBuffer(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1558 #define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer)                                                         \
1559     emberAfPrintString(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1560 #else
1561 #define emberAfManganeseConcentrationMeasurementClusterPrint(...)
1562 #define emberAfManganeseConcentrationMeasurementClusterPrintln(...)
1563 #define emberAfManganeseConcentrationMeasurementClusterFlush()
1564 #define emberAfManganeseConcentrationMeasurementClusterDebugExec(x)
1565 #define emberAfManganeseConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1566 #define emberAfManganeseConcentrationMeasurementClusterPrintString(buffer)
1567 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER)
1568
1569 // Printing macros for cluster: Sulfate Concentration Measurement
1570 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER)
1571 #define emberAfSulfateConcentrationMeasurementClusterPrint(...)                                                                    \
1572     emberAfPrint(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1573 #define emberAfSulfateConcentrationMeasurementClusterPrintln(...)                                                                  \
1574     emberAfPrintln(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1575 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1576 #define emberAfSulfateConcentrationMeasurementClusterFlush()
1577 #define emberAfSulfateConcentrationMeasurementClusterDebugExec(x)                                                                  \
1578     if (emberAfPrintEnabled(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER))                                             \
1579     {                                                                                                                              \
1580         x;                                                                                                                         \
1581     }
1582 #define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                           \
1583     emberAfPrintBuffer(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1584 #define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer)                                                           \
1585     emberAfPrintString(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1586 #else
1587 #define emberAfSulfateConcentrationMeasurementClusterPrint(...)
1588 #define emberAfSulfateConcentrationMeasurementClusterPrintln(...)
1589 #define emberAfSulfateConcentrationMeasurementClusterFlush()
1590 #define emberAfSulfateConcentrationMeasurementClusterDebugExec(x)
1591 #define emberAfSulfateConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1592 #define emberAfSulfateConcentrationMeasurementClusterPrintString(buffer)
1593 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER)
1594
1595 // Printing macros for cluster: Bromodichloromethane Concentration Measurement
1596 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)
1597 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...)                                                       \
1598     emberAfPrint(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1599 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...)                                                     \
1600     emberAfPrintln(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1601 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1602 #define emberAfBromodichloromethaneConcentrationMeasurementClusterFlush()
1603 #define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x)                                                     \
1604     if (emberAfPrintEnabled(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER))                                \
1605     {                                                                                                                              \
1606         x;                                                                                                                         \
1607     }
1608 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                              \
1609     emberAfPrintBuffer(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1610 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer)                                              \
1611     emberAfPrintString(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1612 #else
1613 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrint(...)
1614 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintln(...)
1615 #define emberAfBromodichloromethaneConcentrationMeasurementClusterFlush()
1616 #define emberAfBromodichloromethaneConcentrationMeasurementClusterDebugExec(x)
1617 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1618 #define emberAfBromodichloromethaneConcentrationMeasurementClusterPrintString(buffer)
1619 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMODICHLOROMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)
1620
1621 // Printing macros for cluster: Bromoform Concentration Measurement
1622 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER)
1623 #define emberAfBromoformConcentrationMeasurementClusterPrint(...)                                                                  \
1624     emberAfPrint(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1625 #define emberAfBromoformConcentrationMeasurementClusterPrintln(...)                                                                \
1626     emberAfPrintln(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1627 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1628 #define emberAfBromoformConcentrationMeasurementClusterFlush()
1629 #define emberAfBromoformConcentrationMeasurementClusterDebugExec(x)                                                                \
1630     if (emberAfPrintEnabled(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER))                                           \
1631     {                                                                                                                              \
1632         x;                                                                                                                         \
1633     }
1634 #define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                         \
1635     emberAfPrintBuffer(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1636 #define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer)                                                         \
1637     emberAfPrintString(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1638 #else
1639 #define emberAfBromoformConcentrationMeasurementClusterPrint(...)
1640 #define emberAfBromoformConcentrationMeasurementClusterPrintln(...)
1641 #define emberAfBromoformConcentrationMeasurementClusterFlush()
1642 #define emberAfBromoformConcentrationMeasurementClusterDebugExec(x)
1643 #define emberAfBromoformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1644 #define emberAfBromoformConcentrationMeasurementClusterPrintString(buffer)
1645 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BROMOFORM_CONCENTRATION_MEASUREMENT_CLUSTER)
1646
1647 // Printing macros for cluster: Chlorodibromomethane Concentration Measurement
1648 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)
1649 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...)                                                       \
1650     emberAfPrint(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1651 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...)                                                     \
1652     emberAfPrintln(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1653 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1654 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterFlush()
1655 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x)                                                     \
1656     if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER))                                \
1657     {                                                                                                                              \
1658         x;                                                                                                                         \
1659     }
1660 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                              \
1661     emberAfPrintBuffer(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1662 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer)                                              \
1663     emberAfPrintString(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1664 #else
1665 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrint(...)
1666 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintln(...)
1667 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterFlush()
1668 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterDebugExec(x)
1669 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1670 #define emberAfChlorodibromomethaneConcentrationMeasurementClusterPrintString(buffer)
1671 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER)
1672
1673 // Printing macros for cluster: Chloroform Concentration Measurement
1674 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER)
1675 #define emberAfChloroformConcentrationMeasurementClusterPrint(...)                                                                 \
1676     emberAfPrint(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1677 #define emberAfChloroformConcentrationMeasurementClusterPrintln(...)                                                               \
1678     emberAfPrintln(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1679 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1680 #define emberAfChloroformConcentrationMeasurementClusterFlush()
1681 #define emberAfChloroformConcentrationMeasurementClusterDebugExec(x)                                                               \
1682     if (emberAfPrintEnabled(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER))                                          \
1683     {                                                                                                                              \
1684         x;                                                                                                                         \
1685     }
1686 #define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                        \
1687     emberAfPrintBuffer(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1688 #define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer)                                                        \
1689     emberAfPrintString(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1690 #else
1691 #define emberAfChloroformConcentrationMeasurementClusterPrint(...)
1692 #define emberAfChloroformConcentrationMeasurementClusterPrintln(...)
1693 #define emberAfChloroformConcentrationMeasurementClusterFlush()
1694 #define emberAfChloroformConcentrationMeasurementClusterDebugExec(x)
1695 #define emberAfChloroformConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1696 #define emberAfChloroformConcentrationMeasurementClusterPrintString(buffer)
1697 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER)
1698
1699 // Printing macros for cluster: Sodium Concentration Measurement
1700 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER)
1701 #define emberAfSodiumConcentrationMeasurementClusterPrint(...)                                                                     \
1702     emberAfPrint(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1703 #define emberAfSodiumConcentrationMeasurementClusterPrintln(...)                                                                   \
1704     emberAfPrintln(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, __VA_ARGS__)
1705 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1706 #define emberAfSodiumConcentrationMeasurementClusterFlush()
1707 #define emberAfSodiumConcentrationMeasurementClusterDebugExec(x)                                                                   \
1708     if (emberAfPrintEnabled(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER))                                              \
1709     {                                                                                                                              \
1710         x;                                                                                                                         \
1711     }
1712 #define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)                                            \
1713     emberAfPrintBuffer(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
1714 #define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer)                                                            \
1715     emberAfPrintString(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER, (buffer))
1716 #else
1717 #define emberAfSodiumConcentrationMeasurementClusterPrint(...)
1718 #define emberAfSodiumConcentrationMeasurementClusterPrintln(...)
1719 #define emberAfSodiumConcentrationMeasurementClusterFlush()
1720 #define emberAfSodiumConcentrationMeasurementClusterDebugExec(x)
1721 #define emberAfSodiumConcentrationMeasurementClusterPrintBuffer(buffer, len, withSpace)
1722 #define emberAfSodiumConcentrationMeasurementClusterPrintString(buffer)
1723 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER)
1724
1725 // Printing macros for cluster: IAS Zone
1726 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER)
1727 #define emberAfIasZoneClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, __VA_ARGS__)
1728 #define emberAfIasZoneClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, __VA_ARGS__)
1729 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1730 #define emberAfIasZoneClusterFlush()
1731 #define emberAfIasZoneClusterDebugExec(x)                                                                                          \
1732     if (emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ZONE_CLUSTER))                                                                      \
1733     {                                                                                                                              \
1734         x;                                                                                                                         \
1735     }
1736 #define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace)                                                                   \
1737     emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer), (len), (withSpace))
1738 #define emberAfIasZoneClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_ZONE_CLUSTER, (buffer))
1739 #else
1740 #define emberAfIasZoneClusterPrint(...)
1741 #define emberAfIasZoneClusterPrintln(...)
1742 #define emberAfIasZoneClusterFlush()
1743 #define emberAfIasZoneClusterDebugExec(x)
1744 #define emberAfIasZoneClusterPrintBuffer(buffer, len, withSpace)
1745 #define emberAfIasZoneClusterPrintString(buffer)
1746 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ZONE_CLUSTER)
1747
1748 // Printing macros for cluster: IAS ACE
1749 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER)
1750 #define emberAfIasAceClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_ACE_CLUSTER, __VA_ARGS__)
1751 #define emberAfIasAceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_ACE_CLUSTER, __VA_ARGS__)
1752 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1753 #define emberAfIasAceClusterFlush()
1754 #define emberAfIasAceClusterDebugExec(x)                                                                                           \
1755     if (emberAfPrintEnabled(EMBER_AF_PRINT_IAS_ACE_CLUSTER))                                                                       \
1756     {                                                                                                                              \
1757         x;                                                                                                                         \
1758     }
1759 #define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace)                                                                    \
1760     emberAfPrintBuffer(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer), (len), (withSpace))
1761 #define emberAfIasAceClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_ACE_CLUSTER, (buffer))
1762 #else
1763 #define emberAfIasAceClusterPrint(...)
1764 #define emberAfIasAceClusterPrintln(...)
1765 #define emberAfIasAceClusterFlush()
1766 #define emberAfIasAceClusterDebugExec(x)
1767 #define emberAfIasAceClusterPrintBuffer(buffer, len, withSpace)
1768 #define emberAfIasAceClusterPrintString(buffer)
1769 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_ACE_CLUSTER)
1770
1771 // Printing macros for cluster: IAS WD
1772 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER)
1773 #define emberAfIasWdClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_IAS_WD_CLUSTER, __VA_ARGS__)
1774 #define emberAfIasWdClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_IAS_WD_CLUSTER, __VA_ARGS__)
1775 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1776 #define emberAfIasWdClusterFlush()
1777 #define emberAfIasWdClusterDebugExec(x)                                                                                            \
1778     if (emberAfPrintEnabled(EMBER_AF_PRINT_IAS_WD_CLUSTER))                                                                        \
1779     {                                                                                                                              \
1780         x;                                                                                                                         \
1781     }
1782 #define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace)                                                                     \
1783     emberAfPrintBuffer(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer), (len), (withSpace))
1784 #define emberAfIasWdClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_IAS_WD_CLUSTER, (buffer))
1785 #else
1786 #define emberAfIasWdClusterPrint(...)
1787 #define emberAfIasWdClusterPrintln(...)
1788 #define emberAfIasWdClusterFlush()
1789 #define emberAfIasWdClusterDebugExec(x)
1790 #define emberAfIasWdClusterPrintBuffer(buffer, len, withSpace)
1791 #define emberAfIasWdClusterPrintString(buffer)
1792 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_IAS_WD_CLUSTER)
1793
1794 // Printing macros for cluster: Generic Tunnel
1795 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER)
1796 #define emberAfGenericTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, __VA_ARGS__)
1797 #define emberAfGenericTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, __VA_ARGS__)
1798 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1799 #define emberAfGenericTunnelClusterFlush()
1800 #define emberAfGenericTunnelClusterDebugExec(x)                                                                                    \
1801     if (emberAfPrintEnabled(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER))                                                                \
1802     {                                                                                                                              \
1803         x;                                                                                                                         \
1804     }
1805 #define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace)                                                             \
1806     emberAfPrintBuffer(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
1807 #define emberAfGenericTunnelClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER, (buffer))
1808 #else
1809 #define emberAfGenericTunnelClusterPrint(...)
1810 #define emberAfGenericTunnelClusterPrintln(...)
1811 #define emberAfGenericTunnelClusterFlush()
1812 #define emberAfGenericTunnelClusterDebugExec(x)
1813 #define emberAfGenericTunnelClusterPrintBuffer(buffer, len, withSpace)
1814 #define emberAfGenericTunnelClusterPrintString(buffer)
1815 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GENERIC_TUNNEL_CLUSTER)
1816
1817 // Printing macros for cluster: BACnet Protocol Tunnel
1818 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER)
1819 #define emberAfBacnetProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
1820 #define emberAfBacnetProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
1821 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1822 #define emberAfBacnetProtocolTunnelClusterFlush()
1823 #define emberAfBacnetProtocolTunnelClusterDebugExec(x)                                                                             \
1824     if (emberAfPrintEnabled(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER))                                                        \
1825     {                                                                                                                              \
1826         x;                                                                                                                         \
1827     }
1828 #define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)                                                      \
1829     emberAfPrintBuffer(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
1830 #define emberAfBacnetProtocolTunnelClusterPrintString(buffer)                                                                      \
1831     emberAfPrintString(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER, (buffer))
1832 #else
1833 #define emberAfBacnetProtocolTunnelClusterPrint(...)
1834 #define emberAfBacnetProtocolTunnelClusterPrintln(...)
1835 #define emberAfBacnetProtocolTunnelClusterFlush()
1836 #define emberAfBacnetProtocolTunnelClusterDebugExec(x)
1837 #define emberAfBacnetProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)
1838 #define emberAfBacnetProtocolTunnelClusterPrintString(buffer)
1839 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BACNET_PROTOCOL_TUNNEL_CLUSTER)
1840
1841 // Printing macros for cluster: 11073 Protocol Tunnel
1842 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER)
1843 #define emberAf11073ProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
1844 #define emberAf11073ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
1845 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1846 #define emberAf11073ProtocolTunnelClusterFlush()
1847 #define emberAf11073ProtocolTunnelClusterDebugExec(x)                                                                              \
1848     if (emberAfPrintEnabled(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER))                                                         \
1849     {                                                                                                                              \
1850         x;                                                                                                                         \
1851     }
1852 #define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)                                                       \
1853     emberAfPrintBuffer(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
1854 #define emberAf11073ProtocolTunnelClusterPrintString(buffer)                                                                       \
1855     emberAfPrintString(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER, (buffer))
1856 #else
1857 #define emberAf11073ProtocolTunnelClusterPrint(...)
1858 #define emberAf11073ProtocolTunnelClusterPrintln(...)
1859 #define emberAf11073ProtocolTunnelClusterFlush()
1860 #define emberAf11073ProtocolTunnelClusterDebugExec(x)
1861 #define emberAf11073ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)
1862 #define emberAf11073ProtocolTunnelClusterPrintString(buffer)
1863 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_11073_PROTOCOL_TUNNEL_CLUSTER)
1864
1865 // Printing macros for cluster: ISO 7816 Protocol Tunnel
1866 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER)
1867 #define emberAfIso7816ProtocolTunnelClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
1868 #define emberAfIso7816ProtocolTunnelClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, __VA_ARGS__)
1869 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1870 #define emberAfIso7816ProtocolTunnelClusterFlush()
1871 #define emberAfIso7816ProtocolTunnelClusterDebugExec(x)                                                                            \
1872     if (emberAfPrintEnabled(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER))                                                       \
1873     {                                                                                                                              \
1874         x;                                                                                                                         \
1875     }
1876 #define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)                                                     \
1877     emberAfPrintBuffer(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer), (len), (withSpace))
1878 #define emberAfIso7816ProtocolTunnelClusterPrintString(buffer)                                                                     \
1879     emberAfPrintString(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER, (buffer))
1880 #else
1881 #define emberAfIso7816ProtocolTunnelClusterPrint(...)
1882 #define emberAfIso7816ProtocolTunnelClusterPrintln(...)
1883 #define emberAfIso7816ProtocolTunnelClusterFlush()
1884 #define emberAfIso7816ProtocolTunnelClusterDebugExec(x)
1885 #define emberAfIso7816ProtocolTunnelClusterPrintBuffer(buffer, len, withSpace)
1886 #define emberAfIso7816ProtocolTunnelClusterPrintString(buffer)
1887 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ISO7816_PROTOCOL_TUNNEL_CLUSTER)
1888
1889 // Printing macros for cluster: Price
1890 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER)
1891 #define emberAfPriceClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PRICE_CLUSTER, __VA_ARGS__)
1892 #define emberAfPriceClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PRICE_CLUSTER, __VA_ARGS__)
1893 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1894 #define emberAfPriceClusterFlush()
1895 #define emberAfPriceClusterDebugExec(x)                                                                                            \
1896     if (emberAfPrintEnabled(EMBER_AF_PRINT_PRICE_CLUSTER))                                                                         \
1897     {                                                                                                                              \
1898         x;                                                                                                                         \
1899     }
1900 #define emberAfPriceClusterPrintBuffer(buffer, len, withSpace)                                                                     \
1901     emberAfPrintBuffer(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer), (len), (withSpace))
1902 #define emberAfPriceClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PRICE_CLUSTER, (buffer))
1903 #else
1904 #define emberAfPriceClusterPrint(...)
1905 #define emberAfPriceClusterPrintln(...)
1906 #define emberAfPriceClusterFlush()
1907 #define emberAfPriceClusterDebugExec(x)
1908 #define emberAfPriceClusterPrintBuffer(buffer, len, withSpace)
1909 #define emberAfPriceClusterPrintString(buffer)
1910 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PRICE_CLUSTER)
1911
1912 // Printing macros for cluster: Demand Response and Load Control
1913 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER)
1914 #define emberAfDemandResponseLoadControlClusterPrint(...)                                                                          \
1915     emberAfPrint(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__)
1916 #define emberAfDemandResponseLoadControlClusterPrintln(...)                                                                        \
1917     emberAfPrintln(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, __VA_ARGS__)
1918 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1919 #define emberAfDemandResponseLoadControlClusterFlush()
1920 #define emberAfDemandResponseLoadControlClusterDebugExec(x)                                                                        \
1921     if (emberAfPrintEnabled(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER))                                                  \
1922     {                                                                                                                              \
1923         x;                                                                                                                         \
1924     }
1925 #define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace)                                                 \
1926     emberAfPrintBuffer(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer), (len), (withSpace))
1927 #define emberAfDemandResponseLoadControlClusterPrintString(buffer)                                                                 \
1928     emberAfPrintString(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER, (buffer))
1929 #else
1930 #define emberAfDemandResponseLoadControlClusterPrint(...)
1931 #define emberAfDemandResponseLoadControlClusterPrintln(...)
1932 #define emberAfDemandResponseLoadControlClusterFlush()
1933 #define emberAfDemandResponseLoadControlClusterDebugExec(x)
1934 #define emberAfDemandResponseLoadControlClusterPrintBuffer(buffer, len, withSpace)
1935 #define emberAfDemandResponseLoadControlClusterPrintString(buffer)
1936 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEMAND_RESPONSE_LOAD_CONTROL_CLUSTER)
1937
1938 // Printing macros for cluster: Simple Metering
1939 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER)
1940 #define emberAfSimpleMeteringClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, __VA_ARGS__)
1941 #define emberAfSimpleMeteringClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, __VA_ARGS__)
1942 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1943 #define emberAfSimpleMeteringClusterFlush()
1944 #define emberAfSimpleMeteringClusterDebugExec(x)                                                                                   \
1945     if (emberAfPrintEnabled(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER))                                                               \
1946     {                                                                                                                              \
1947         x;                                                                                                                         \
1948     }
1949 #define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace)                                                            \
1950     emberAfPrintBuffer(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer), (len), (withSpace))
1951 #define emberAfSimpleMeteringClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER, (buffer))
1952 #else
1953 #define emberAfSimpleMeteringClusterPrint(...)
1954 #define emberAfSimpleMeteringClusterPrintln(...)
1955 #define emberAfSimpleMeteringClusterFlush()
1956 #define emberAfSimpleMeteringClusterDebugExec(x)
1957 #define emberAfSimpleMeteringClusterPrintBuffer(buffer, len, withSpace)
1958 #define emberAfSimpleMeteringClusterPrintString(buffer)
1959 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SIMPLE_METERING_CLUSTER)
1960
1961 // Printing macros for cluster: Messaging
1962 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER)
1963 #define emberAfMessagingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MESSAGING_CLUSTER, __VA_ARGS__)
1964 #define emberAfMessagingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MESSAGING_CLUSTER, __VA_ARGS__)
1965 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1966 #define emberAfMessagingClusterFlush()
1967 #define emberAfMessagingClusterDebugExec(x)                                                                                        \
1968     if (emberAfPrintEnabled(EMBER_AF_PRINT_MESSAGING_CLUSTER))                                                                     \
1969     {                                                                                                                              \
1970         x;                                                                                                                         \
1971     }
1972 #define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace)                                                                 \
1973     emberAfPrintBuffer(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer), (len), (withSpace))
1974 #define emberAfMessagingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MESSAGING_CLUSTER, (buffer))
1975 #else
1976 #define emberAfMessagingClusterPrint(...)
1977 #define emberAfMessagingClusterPrintln(...)
1978 #define emberAfMessagingClusterFlush()
1979 #define emberAfMessagingClusterDebugExec(x)
1980 #define emberAfMessagingClusterPrintBuffer(buffer, len, withSpace)
1981 #define emberAfMessagingClusterPrintString(buffer)
1982 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MESSAGING_CLUSTER)
1983
1984 // Printing macros for cluster: Tunneling
1985 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER)
1986 #define emberAfTunnelingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_TUNNELING_CLUSTER, __VA_ARGS__)
1987 #define emberAfTunnelingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_TUNNELING_CLUSTER, __VA_ARGS__)
1988 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
1989 #define emberAfTunnelingClusterFlush()
1990 #define emberAfTunnelingClusterDebugExec(x)                                                                                        \
1991     if (emberAfPrintEnabled(EMBER_AF_PRINT_TUNNELING_CLUSTER))                                                                     \
1992     {                                                                                                                              \
1993         x;                                                                                                                         \
1994     }
1995 #define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace)                                                                 \
1996     emberAfPrintBuffer(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer), (len), (withSpace))
1997 #define emberAfTunnelingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_TUNNELING_CLUSTER, (buffer))
1998 #else
1999 #define emberAfTunnelingClusterPrint(...)
2000 #define emberAfTunnelingClusterPrintln(...)
2001 #define emberAfTunnelingClusterFlush()
2002 #define emberAfTunnelingClusterDebugExec(x)
2003 #define emberAfTunnelingClusterPrintBuffer(buffer, len, withSpace)
2004 #define emberAfTunnelingClusterPrintString(buffer)
2005 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_TUNNELING_CLUSTER)
2006
2007 // Printing macros for cluster: Prepayment
2008 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER)
2009 #define emberAfPrepaymentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, __VA_ARGS__)
2010 #define emberAfPrepaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, __VA_ARGS__)
2011 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2012 #define emberAfPrepaymentClusterFlush()
2013 #define emberAfPrepaymentClusterDebugExec(x)                                                                                       \
2014     if (emberAfPrintEnabled(EMBER_AF_PRINT_PREPAYMENT_CLUSTER))                                                                    \
2015     {                                                                                                                              \
2016         x;                                                                                                                         \
2017     }
2018 #define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace)                                                                \
2019     emberAfPrintBuffer(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer), (len), (withSpace))
2020 #define emberAfPrepaymentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PREPAYMENT_CLUSTER, (buffer))
2021 #else
2022 #define emberAfPrepaymentClusterPrint(...)
2023 #define emberAfPrepaymentClusterPrintln(...)
2024 #define emberAfPrepaymentClusterFlush()
2025 #define emberAfPrepaymentClusterDebugExec(x)
2026 #define emberAfPrepaymentClusterPrintBuffer(buffer, len, withSpace)
2027 #define emberAfPrepaymentClusterPrintString(buffer)
2028 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PREPAYMENT_CLUSTER)
2029
2030 // Printing macros for cluster: Energy Management
2031 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER)
2032 #define emberAfEnergyManagementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, __VA_ARGS__)
2033 #define emberAfEnergyManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, __VA_ARGS__)
2034 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2035 #define emberAfEnergyManagementClusterFlush()
2036 #define emberAfEnergyManagementClusterDebugExec(x)                                                                                 \
2037     if (emberAfPrintEnabled(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER))                                                             \
2038     {                                                                                                                              \
2039         x;                                                                                                                         \
2040     }
2041 #define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace)                                                          \
2042     emberAfPrintBuffer(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace))
2043 #define emberAfEnergyManagementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER, (buffer))
2044 #else
2045 #define emberAfEnergyManagementClusterPrint(...)
2046 #define emberAfEnergyManagementClusterPrintln(...)
2047 #define emberAfEnergyManagementClusterFlush()
2048 #define emberAfEnergyManagementClusterDebugExec(x)
2049 #define emberAfEnergyManagementClusterPrintBuffer(buffer, len, withSpace)
2050 #define emberAfEnergyManagementClusterPrintString(buffer)
2051 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ENERGY_MANAGEMENT_CLUSTER)
2052
2053 // Printing macros for cluster: Calendar
2054 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER)
2055 #define emberAfCalendarClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CALENDAR_CLUSTER, __VA_ARGS__)
2056 #define emberAfCalendarClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CALENDAR_CLUSTER, __VA_ARGS__)
2057 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2058 #define emberAfCalendarClusterFlush()
2059 #define emberAfCalendarClusterDebugExec(x)                                                                                         \
2060     if (emberAfPrintEnabled(EMBER_AF_PRINT_CALENDAR_CLUSTER))                                                                      \
2061     {                                                                                                                              \
2062         x;                                                                                                                         \
2063     }
2064 #define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace)                                                                  \
2065     emberAfPrintBuffer(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer), (len), (withSpace))
2066 #define emberAfCalendarClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CALENDAR_CLUSTER, (buffer))
2067 #else
2068 #define emberAfCalendarClusterPrint(...)
2069 #define emberAfCalendarClusterPrintln(...)
2070 #define emberAfCalendarClusterFlush()
2071 #define emberAfCalendarClusterDebugExec(x)
2072 #define emberAfCalendarClusterPrintBuffer(buffer, len, withSpace)
2073 #define emberAfCalendarClusterPrintString(buffer)
2074 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CALENDAR_CLUSTER)
2075
2076 // Printing macros for cluster: Device Management
2077 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER)
2078 #define emberAfDeviceManagementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, __VA_ARGS__)
2079 #define emberAfDeviceManagementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, __VA_ARGS__)
2080 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2081 #define emberAfDeviceManagementClusterFlush()
2082 #define emberAfDeviceManagementClusterDebugExec(x)                                                                                 \
2083     if (emberAfPrintEnabled(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER))                                                             \
2084     {                                                                                                                              \
2085         x;                                                                                                                         \
2086     }
2087 #define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace)                                                          \
2088     emberAfPrintBuffer(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer), (len), (withSpace))
2089 #define emberAfDeviceManagementClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER, (buffer))
2090 #else
2091 #define emberAfDeviceManagementClusterPrint(...)
2092 #define emberAfDeviceManagementClusterPrintln(...)
2093 #define emberAfDeviceManagementClusterFlush()
2094 #define emberAfDeviceManagementClusterDebugExec(x)
2095 #define emberAfDeviceManagementClusterPrintBuffer(buffer, len, withSpace)
2096 #define emberAfDeviceManagementClusterPrintString(buffer)
2097 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEVICE_MANAGEMENT_CLUSTER)
2098
2099 // Printing macros for cluster: Events
2100 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER)
2101 #define emberAfEventsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_EVENTS_CLUSTER, __VA_ARGS__)
2102 #define emberAfEventsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_EVENTS_CLUSTER, __VA_ARGS__)
2103 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2104 #define emberAfEventsClusterFlush()
2105 #define emberAfEventsClusterDebugExec(x)                                                                                           \
2106     if (emberAfPrintEnabled(EMBER_AF_PRINT_EVENTS_CLUSTER))                                                                        \
2107     {                                                                                                                              \
2108         x;                                                                                                                         \
2109     }
2110 #define emberAfEventsClusterPrintBuffer(buffer, len, withSpace)                                                                    \
2111     emberAfPrintBuffer(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer), (len), (withSpace))
2112 #define emberAfEventsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_EVENTS_CLUSTER, (buffer))
2113 #else
2114 #define emberAfEventsClusterPrint(...)
2115 #define emberAfEventsClusterPrintln(...)
2116 #define emberAfEventsClusterFlush()
2117 #define emberAfEventsClusterDebugExec(x)
2118 #define emberAfEventsClusterPrintBuffer(buffer, len, withSpace)
2119 #define emberAfEventsClusterPrintString(buffer)
2120 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_EVENTS_CLUSTER)
2121
2122 // Printing macros for cluster: MDU Pairing
2123 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER)
2124 #define emberAfMduPairingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, __VA_ARGS__)
2125 #define emberAfMduPairingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, __VA_ARGS__)
2126 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2127 #define emberAfMduPairingClusterFlush()
2128 #define emberAfMduPairingClusterDebugExec(x)                                                                                       \
2129     if (emberAfPrintEnabled(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER))                                                                   \
2130     {                                                                                                                              \
2131         x;                                                                                                                         \
2132     }
2133 #define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace)                                                                \
2134     emberAfPrintBuffer(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer), (len), (withSpace))
2135 #define emberAfMduPairingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER, (buffer))
2136 #else
2137 #define emberAfMduPairingClusterPrint(...)
2138 #define emberAfMduPairingClusterPrintln(...)
2139 #define emberAfMduPairingClusterFlush()
2140 #define emberAfMduPairingClusterDebugExec(x)
2141 #define emberAfMduPairingClusterPrintBuffer(buffer, len, withSpace)
2142 #define emberAfMduPairingClusterPrintString(buffer)
2143 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MDU_PAIRING_CLUSTER)
2144
2145 // Printing macros for cluster: Sub-GHz
2146 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER)
2147 #define emberAfSubGhzClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, __VA_ARGS__)
2148 #define emberAfSubGhzClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, __VA_ARGS__)
2149 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2150 #define emberAfSubGhzClusterFlush()
2151 #define emberAfSubGhzClusterDebugExec(x)                                                                                           \
2152     if (emberAfPrintEnabled(EMBER_AF_PRINT_SUB_GHZ_CLUSTER))                                                                       \
2153     {                                                                                                                              \
2154         x;                                                                                                                         \
2155     }
2156 #define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace)                                                                    \
2157     emberAfPrintBuffer(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer), (len), (withSpace))
2158 #define emberAfSubGhzClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SUB_GHZ_CLUSTER, (buffer))
2159 #else
2160 #define emberAfSubGhzClusterPrint(...)
2161 #define emberAfSubGhzClusterPrintln(...)
2162 #define emberAfSubGhzClusterFlush()
2163 #define emberAfSubGhzClusterDebugExec(x)
2164 #define emberAfSubGhzClusterPrintBuffer(buffer, len, withSpace)
2165 #define emberAfSubGhzClusterPrintString(buffer)
2166 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SUB_GHZ_CLUSTER)
2167
2168 // Printing macros for cluster: Key Establishment
2169 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER)
2170 #define emberAfKeyEstablishmentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, __VA_ARGS__)
2171 #define emberAfKeyEstablishmentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, __VA_ARGS__)
2172 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2173 #define emberAfKeyEstablishmentClusterFlush()
2174 #define emberAfKeyEstablishmentClusterDebugExec(x)                                                                                 \
2175     if (emberAfPrintEnabled(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER))                                                             \
2176     {                                                                                                                              \
2177         x;                                                                                                                         \
2178     }
2179 #define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace)                                                          \
2180     emberAfPrintBuffer(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer), (len), (withSpace))
2181 #define emberAfKeyEstablishmentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER, (buffer))
2182 #else
2183 #define emberAfKeyEstablishmentClusterPrint(...)
2184 #define emberAfKeyEstablishmentClusterPrintln(...)
2185 #define emberAfKeyEstablishmentClusterFlush()
2186 #define emberAfKeyEstablishmentClusterDebugExec(x)
2187 #define emberAfKeyEstablishmentClusterPrintBuffer(buffer, len, withSpace)
2188 #define emberAfKeyEstablishmentClusterPrintString(buffer)
2189 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_KEY_ESTABLISHMENT_CLUSTER)
2190
2191 // Printing macros for cluster: Information
2192 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER)
2193 #define emberAfInformationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_INFORMATION_CLUSTER, __VA_ARGS__)
2194 #define emberAfInformationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_INFORMATION_CLUSTER, __VA_ARGS__)
2195 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2196 #define emberAfInformationClusterFlush()
2197 #define emberAfInformationClusterDebugExec(x)                                                                                      \
2198     if (emberAfPrintEnabled(EMBER_AF_PRINT_INFORMATION_CLUSTER))                                                                   \
2199     {                                                                                                                              \
2200         x;                                                                                                                         \
2201     }
2202 #define emberAfInformationClusterPrintBuffer(buffer, len, withSpace)                                                               \
2203     emberAfPrintBuffer(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer), (len), (withSpace))
2204 #define emberAfInformationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_INFORMATION_CLUSTER, (buffer))
2205 #else
2206 #define emberAfInformationClusterPrint(...)
2207 #define emberAfInformationClusterPrintln(...)
2208 #define emberAfInformationClusterFlush()
2209 #define emberAfInformationClusterDebugExec(x)
2210 #define emberAfInformationClusterPrintBuffer(buffer, len, withSpace)
2211 #define emberAfInformationClusterPrintString(buffer)
2212 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_INFORMATION_CLUSTER)
2213
2214 // Printing macros for cluster: Data Sharing
2215 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER)
2216 #define emberAfDataSharingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, __VA_ARGS__)
2217 #define emberAfDataSharingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, __VA_ARGS__)
2218 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2219 #define emberAfDataSharingClusterFlush()
2220 #define emberAfDataSharingClusterDebugExec(x)                                                                                      \
2221     if (emberAfPrintEnabled(EMBER_AF_PRINT_DATA_SHARING_CLUSTER))                                                                  \
2222     {                                                                                                                              \
2223         x;                                                                                                                         \
2224     }
2225 #define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace)                                                               \
2226     emberAfPrintBuffer(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer), (len), (withSpace))
2227 #define emberAfDataSharingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DATA_SHARING_CLUSTER, (buffer))
2228 #else
2229 #define emberAfDataSharingClusterPrint(...)
2230 #define emberAfDataSharingClusterPrintln(...)
2231 #define emberAfDataSharingClusterFlush()
2232 #define emberAfDataSharingClusterDebugExec(x)
2233 #define emberAfDataSharingClusterPrintBuffer(buffer, len, withSpace)
2234 #define emberAfDataSharingClusterPrintString(buffer)
2235 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_SHARING_CLUSTER)
2236
2237 // Printing macros for cluster: Gaming
2238 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER)
2239 #define emberAfGamingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_GAMING_CLUSTER, __VA_ARGS__)
2240 #define emberAfGamingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_GAMING_CLUSTER, __VA_ARGS__)
2241 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2242 #define emberAfGamingClusterFlush()
2243 #define emberAfGamingClusterDebugExec(x)                                                                                           \
2244     if (emberAfPrintEnabled(EMBER_AF_PRINT_GAMING_CLUSTER))                                                                        \
2245     {                                                                                                                              \
2246         x;                                                                                                                         \
2247     }
2248 #define emberAfGamingClusterPrintBuffer(buffer, len, withSpace)                                                                    \
2249     emberAfPrintBuffer(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer), (len), (withSpace))
2250 #define emberAfGamingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_GAMING_CLUSTER, (buffer))
2251 #else
2252 #define emberAfGamingClusterPrint(...)
2253 #define emberAfGamingClusterPrintln(...)
2254 #define emberAfGamingClusterFlush()
2255 #define emberAfGamingClusterDebugExec(x)
2256 #define emberAfGamingClusterPrintBuffer(buffer, len, withSpace)
2257 #define emberAfGamingClusterPrintString(buffer)
2258 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_GAMING_CLUSTER)
2259
2260 // Printing macros for cluster: Data Rate Control
2261 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER)
2262 #define emberAfDataRateControlClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, __VA_ARGS__)
2263 #define emberAfDataRateControlClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, __VA_ARGS__)
2264 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2265 #define emberAfDataRateControlClusterFlush()
2266 #define emberAfDataRateControlClusterDebugExec(x)                                                                                  \
2267     if (emberAfPrintEnabled(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER))                                                             \
2268     {                                                                                                                              \
2269         x;                                                                                                                         \
2270     }
2271 #define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace)                                                           \
2272     emberAfPrintBuffer(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer), (len), (withSpace))
2273 #define emberAfDataRateControlClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER, (buffer))
2274 #else
2275 #define emberAfDataRateControlClusterPrint(...)
2276 #define emberAfDataRateControlClusterPrintln(...)
2277 #define emberAfDataRateControlClusterFlush()
2278 #define emberAfDataRateControlClusterDebugExec(x)
2279 #define emberAfDataRateControlClusterPrintBuffer(buffer, len, withSpace)
2280 #define emberAfDataRateControlClusterPrintString(buffer)
2281 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DATA_RATE_CONTROL_CLUSTER)
2282
2283 // Printing macros for cluster: Voice over ZigBee
2284 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER)
2285 #define emberAfVoiceOverZigbeeClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, __VA_ARGS__)
2286 #define emberAfVoiceOverZigbeeClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, __VA_ARGS__)
2287 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2288 #define emberAfVoiceOverZigbeeClusterFlush()
2289 #define emberAfVoiceOverZigbeeClusterDebugExec(x)                                                                                  \
2290     if (emberAfPrintEnabled(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER))                                                             \
2291     {                                                                                                                              \
2292         x;                                                                                                                         \
2293     }
2294 #define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace)                                                           \
2295     emberAfPrintBuffer(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer), (len), (withSpace))
2296 #define emberAfVoiceOverZigbeeClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER, (buffer))
2297 #else
2298 #define emberAfVoiceOverZigbeeClusterPrint(...)
2299 #define emberAfVoiceOverZigbeeClusterPrintln(...)
2300 #define emberAfVoiceOverZigbeeClusterFlush()
2301 #define emberAfVoiceOverZigbeeClusterDebugExec(x)
2302 #define emberAfVoiceOverZigbeeClusterPrintBuffer(buffer, len, withSpace)
2303 #define emberAfVoiceOverZigbeeClusterPrintString(buffer)
2304 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_VOICE_OVER_ZIGBEE_CLUSTER)
2305
2306 // Printing macros for cluster: Chatting
2307 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER)
2308 #define emberAfChattingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_CHATTING_CLUSTER, __VA_ARGS__)
2309 #define emberAfChattingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_CHATTING_CLUSTER, __VA_ARGS__)
2310 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2311 #define emberAfChattingClusterFlush()
2312 #define emberAfChattingClusterDebugExec(x)                                                                                         \
2313     if (emberAfPrintEnabled(EMBER_AF_PRINT_CHATTING_CLUSTER))                                                                      \
2314     {                                                                                                                              \
2315         x;                                                                                                                         \
2316     }
2317 #define emberAfChattingClusterPrintBuffer(buffer, len, withSpace)                                                                  \
2318     emberAfPrintBuffer(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer), (len), (withSpace))
2319 #define emberAfChattingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CHATTING_CLUSTER, (buffer))
2320 #else
2321 #define emberAfChattingClusterPrint(...)
2322 #define emberAfChattingClusterPrintln(...)
2323 #define emberAfChattingClusterFlush()
2324 #define emberAfChattingClusterDebugExec(x)
2325 #define emberAfChattingClusterPrintBuffer(buffer, len, withSpace)
2326 #define emberAfChattingClusterPrintString(buffer)
2327 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CHATTING_CLUSTER)
2328
2329 // Printing macros for cluster: Payment
2330 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER)
2331 #define emberAfPaymentClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_PAYMENT_CLUSTER, __VA_ARGS__)
2332 #define emberAfPaymentClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_PAYMENT_CLUSTER, __VA_ARGS__)
2333 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2334 #define emberAfPaymentClusterFlush()
2335 #define emberAfPaymentClusterDebugExec(x)                                                                                          \
2336     if (emberAfPrintEnabled(EMBER_AF_PRINT_PAYMENT_CLUSTER))                                                                       \
2337     {                                                                                                                              \
2338         x;                                                                                                                         \
2339     }
2340 #define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace)                                                                   \
2341     emberAfPrintBuffer(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer), (len), (withSpace))
2342 #define emberAfPaymentClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_PAYMENT_CLUSTER, (buffer))
2343 #else
2344 #define emberAfPaymentClusterPrint(...)
2345 #define emberAfPaymentClusterPrintln(...)
2346 #define emberAfPaymentClusterFlush()
2347 #define emberAfPaymentClusterDebugExec(x)
2348 #define emberAfPaymentClusterPrintBuffer(buffer, len, withSpace)
2349 #define emberAfPaymentClusterPrintString(buffer)
2350 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_PAYMENT_CLUSTER)
2351
2352 // Printing macros for cluster: Billing
2353 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER)
2354 #define emberAfBillingClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_BILLING_CLUSTER, __VA_ARGS__)
2355 #define emberAfBillingClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_BILLING_CLUSTER, __VA_ARGS__)
2356 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2357 #define emberAfBillingClusterFlush()
2358 #define emberAfBillingClusterDebugExec(x)                                                                                          \
2359     if (emberAfPrintEnabled(EMBER_AF_PRINT_BILLING_CLUSTER))                                                                       \
2360     {                                                                                                                              \
2361         x;                                                                                                                         \
2362     }
2363 #define emberAfBillingClusterPrintBuffer(buffer, len, withSpace)                                                                   \
2364     emberAfPrintBuffer(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer), (len), (withSpace))
2365 #define emberAfBillingClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_BILLING_CLUSTER, (buffer))
2366 #else
2367 #define emberAfBillingClusterPrint(...)
2368 #define emberAfBillingClusterPrintln(...)
2369 #define emberAfBillingClusterFlush()
2370 #define emberAfBillingClusterDebugExec(x)
2371 #define emberAfBillingClusterPrintBuffer(buffer, len, withSpace)
2372 #define emberAfBillingClusterPrintString(buffer)
2373 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_BILLING_CLUSTER)
2374
2375 // Printing macros for cluster: Appliance Identification
2376 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER)
2377 #define emberAfApplianceIdentificationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, __VA_ARGS__)
2378 #define emberAfApplianceIdentificationClusterPrintln(...)                                                                          \
2379     emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, __VA_ARGS__)
2380 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2381 #define emberAfApplianceIdentificationClusterFlush()
2382 #define emberAfApplianceIdentificationClusterDebugExec(x)                                                                          \
2383     if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER))                                                      \
2384     {                                                                                                                              \
2385         x;                                                                                                                         \
2386     }
2387 #define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace)                                                   \
2388     emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace))
2389 #define emberAfApplianceIdentificationClusterPrintString(buffer)                                                                   \
2390     emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER, (buffer))
2391 #else
2392 #define emberAfApplianceIdentificationClusterPrint(...)
2393 #define emberAfApplianceIdentificationClusterPrintln(...)
2394 #define emberAfApplianceIdentificationClusterFlush()
2395 #define emberAfApplianceIdentificationClusterDebugExec(x)
2396 #define emberAfApplianceIdentificationClusterPrintBuffer(buffer, len, withSpace)
2397 #define emberAfApplianceIdentificationClusterPrintString(buffer)
2398 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_IDENTIFICATION_CLUSTER)
2399
2400 // Printing macros for cluster: Meter Identification
2401 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER)
2402 #define emberAfMeterIdentificationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, __VA_ARGS__)
2403 #define emberAfMeterIdentificationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, __VA_ARGS__)
2404 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2405 #define emberAfMeterIdentificationClusterFlush()
2406 #define emberAfMeterIdentificationClusterDebugExec(x)                                                                              \
2407     if (emberAfPrintEnabled(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER))                                                          \
2408     {                                                                                                                              \
2409         x;                                                                                                                         \
2410     }
2411 #define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace)                                                       \
2412     emberAfPrintBuffer(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer), (len), (withSpace))
2413 #define emberAfMeterIdentificationClusterPrintString(buffer)                                                                       \
2414     emberAfPrintString(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER, (buffer))
2415 #else
2416 #define emberAfMeterIdentificationClusterPrint(...)
2417 #define emberAfMeterIdentificationClusterPrintln(...)
2418 #define emberAfMeterIdentificationClusterFlush()
2419 #define emberAfMeterIdentificationClusterDebugExec(x)
2420 #define emberAfMeterIdentificationClusterPrintBuffer(buffer, len, withSpace)
2421 #define emberAfMeterIdentificationClusterPrintString(buffer)
2422 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_METER_IDENTIFICATION_CLUSTER)
2423
2424 // Printing macros for cluster: Appliance Events and Alert
2425 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER)
2426 #define emberAfApplianceEventsAndAlertClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, __VA_ARGS__)
2427 #define emberAfApplianceEventsAndAlertClusterPrintln(...)                                                                          \
2428     emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, __VA_ARGS__)
2429 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2430 #define emberAfApplianceEventsAndAlertClusterFlush()
2431 #define emberAfApplianceEventsAndAlertClusterDebugExec(x)                                                                          \
2432     if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER))                                                    \
2433     {                                                                                                                              \
2434         x;                                                                                                                         \
2435     }
2436 #define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace)                                                   \
2437     emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer), (len), (withSpace))
2438 #define emberAfApplianceEventsAndAlertClusterPrintString(buffer)                                                                   \
2439     emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER, (buffer))
2440 #else
2441 #define emberAfApplianceEventsAndAlertClusterPrint(...)
2442 #define emberAfApplianceEventsAndAlertClusterPrintln(...)
2443 #define emberAfApplianceEventsAndAlertClusterFlush()
2444 #define emberAfApplianceEventsAndAlertClusterDebugExec(x)
2445 #define emberAfApplianceEventsAndAlertClusterPrintBuffer(buffer, len, withSpace)
2446 #define emberAfApplianceEventsAndAlertClusterPrintString(buffer)
2447 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_EVENTS_AND_ALERT_CLUSTER)
2448
2449 // Printing macros for cluster: Appliance Statistics
2450 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER)
2451 #define emberAfApplianceStatisticsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, __VA_ARGS__)
2452 #define emberAfApplianceStatisticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, __VA_ARGS__)
2453 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2454 #define emberAfApplianceStatisticsClusterFlush()
2455 #define emberAfApplianceStatisticsClusterDebugExec(x)                                                                              \
2456     if (emberAfPrintEnabled(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER))                                                          \
2457     {                                                                                                                              \
2458         x;                                                                                                                         \
2459     }
2460 #define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace)                                                       \
2461     emberAfPrintBuffer(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer), (len), (withSpace))
2462 #define emberAfApplianceStatisticsClusterPrintString(buffer)                                                                       \
2463     emberAfPrintString(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER, (buffer))
2464 #else
2465 #define emberAfApplianceStatisticsClusterPrint(...)
2466 #define emberAfApplianceStatisticsClusterPrintln(...)
2467 #define emberAfApplianceStatisticsClusterFlush()
2468 #define emberAfApplianceStatisticsClusterDebugExec(x)
2469 #define emberAfApplianceStatisticsClusterPrintBuffer(buffer, len, withSpace)
2470 #define emberAfApplianceStatisticsClusterPrintString(buffer)
2471 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APPLIANCE_STATISTICS_CLUSTER)
2472
2473 // Printing macros for cluster: Electrical Measurement
2474 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER)
2475 #define emberAfElectricalMeasurementClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, __VA_ARGS__)
2476 #define emberAfElectricalMeasurementClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, __VA_ARGS__)
2477 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2478 #define emberAfElectricalMeasurementClusterFlush()
2479 #define emberAfElectricalMeasurementClusterDebugExec(x)                                                                            \
2480     if (emberAfPrintEnabled(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER))                                                        \
2481     {                                                                                                                              \
2482         x;                                                                                                                         \
2483     }
2484 #define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace)                                                     \
2485     emberAfPrintBuffer(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer), (len), (withSpace))
2486 #define emberAfElectricalMeasurementClusterPrintString(buffer)                                                                     \
2487     emberAfPrintString(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER, (buffer))
2488 #else
2489 #define emberAfElectricalMeasurementClusterPrint(...)
2490 #define emberAfElectricalMeasurementClusterPrintln(...)
2491 #define emberAfElectricalMeasurementClusterFlush()
2492 #define emberAfElectricalMeasurementClusterDebugExec(x)
2493 #define emberAfElectricalMeasurementClusterPrintBuffer(buffer, len, withSpace)
2494 #define emberAfElectricalMeasurementClusterPrintString(buffer)
2495 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ELECTRICAL_MEASUREMENT_CLUSTER)
2496
2497 // Printing macros for cluster: Diagnostics
2498 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER)
2499 #define emberAfDiagnosticsClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, __VA_ARGS__)
2500 #define emberAfDiagnosticsClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, __VA_ARGS__)
2501 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2502 #define emberAfDiagnosticsClusterFlush()
2503 #define emberAfDiagnosticsClusterDebugExec(x)                                                                                      \
2504     if (emberAfPrintEnabled(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER))                                                                   \
2505     {                                                                                                                              \
2506         x;                                                                                                                         \
2507     }
2508 #define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace)                                                               \
2509     emberAfPrintBuffer(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer), (len), (withSpace))
2510 #define emberAfDiagnosticsClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER, (buffer))
2511 #else
2512 #define emberAfDiagnosticsClusterPrint(...)
2513 #define emberAfDiagnosticsClusterPrintln(...)
2514 #define emberAfDiagnosticsClusterFlush()
2515 #define emberAfDiagnosticsClusterDebugExec(x)
2516 #define emberAfDiagnosticsClusterPrintBuffer(buffer, len, withSpace)
2517 #define emberAfDiagnosticsClusterPrintString(buffer)
2518 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DIAGNOSTICS_CLUSTER)
2519
2520 // Printing macros for cluster: ZLL Commissioning
2521 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER)
2522 #define emberAfZllCommissioningClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, __VA_ARGS__)
2523 #define emberAfZllCommissioningClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, __VA_ARGS__)
2524 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2525 #define emberAfZllCommissioningClusterFlush()
2526 #define emberAfZllCommissioningClusterDebugExec(x)                                                                                 \
2527     if (emberAfPrintEnabled(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER))                                                             \
2528     {                                                                                                                              \
2529         x;                                                                                                                         \
2530     }
2531 #define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace)                                                          \
2532     emberAfPrintBuffer(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer), (len), (withSpace))
2533 #define emberAfZllCommissioningClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER, (buffer))
2534 #else
2535 #define emberAfZllCommissioningClusterPrint(...)
2536 #define emberAfZllCommissioningClusterPrintln(...)
2537 #define emberAfZllCommissioningClusterFlush()
2538 #define emberAfZllCommissioningClusterDebugExec(x)
2539 #define emberAfZllCommissioningClusterPrintBuffer(buffer, len, withSpace)
2540 #define emberAfZllCommissioningClusterPrintString(buffer)
2541 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZLL_COMMISSIONING_CLUSTER)
2542
2543 // Printing macros for cluster: Sample Mfg Specific Cluster
2544 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER)
2545 #define emberAfSampleMfgSpecificClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, __VA_ARGS__)
2546 #define emberAfSampleMfgSpecificClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, __VA_ARGS__)
2547 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2548 #define emberAfSampleMfgSpecificClusterFlush()
2549 #define emberAfSampleMfgSpecificClusterDebugExec(x)                                                                                \
2550     if (emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER))                                                           \
2551     {                                                                                                                              \
2552         x;                                                                                                                         \
2553     }
2554 #define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace)                                                         \
2555     emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer), (len), (withSpace))
2556 #define emberAfSampleMfgSpecificClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER, (buffer))
2557 #else
2558 #define emberAfSampleMfgSpecificClusterPrint(...)
2559 #define emberAfSampleMfgSpecificClusterPrintln(...)
2560 #define emberAfSampleMfgSpecificClusterFlush()
2561 #define emberAfSampleMfgSpecificClusterDebugExec(x)
2562 #define emberAfSampleMfgSpecificClusterPrintBuffer(buffer, len, withSpace)
2563 #define emberAfSampleMfgSpecificClusterPrintString(buffer)
2564 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER)
2565
2566 // Printing macros for cluster: Sample Mfg Specific Cluster 2
2567 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2)
2568 #define emberAfSampleMfgSpecificCluster2Print(...) emberAfPrint(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, __VA_ARGS__)
2569 #define emberAfSampleMfgSpecificCluster2Println(...) emberAfPrintln(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, __VA_ARGS__)
2570 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2571 #define emberAfSampleMfgSpecificCluster2Flush()
2572 #define emberAfSampleMfgSpecificCluster2DebugExec(x)                                                                               \
2573     if (emberAfPrintEnabled(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2))                                                         \
2574     {                                                                                                                              \
2575         x;                                                                                                                         \
2576     }
2577 #define emberAfSampleMfgSpecificCluster2PrintBuffer(buffer, len, withSpace)                                                        \
2578     emberAfPrintBuffer(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, (buffer), (len), (withSpace))
2579 #define emberAfSampleMfgSpecificCluster2PrintString(buffer)                                                                        \
2580     emberAfPrintString(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2, (buffer))
2581 #else
2582 #define emberAfSampleMfgSpecificCluster2Print(...)
2583 #define emberAfSampleMfgSpecificCluster2Println(...)
2584 #define emberAfSampleMfgSpecificCluster2Flush()
2585 #define emberAfSampleMfgSpecificCluster2DebugExec(x)
2586 #define emberAfSampleMfgSpecificCluster2PrintBuffer(buffer, len, withSpace)
2587 #define emberAfSampleMfgSpecificCluster2PrintString(buffer)
2588 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SAMPLE_MFG_SPECIFIC_CLUSTER_2)
2589
2590 // Printing macros for cluster: Configuration Cluster
2591 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER)
2592 #define emberAfOtaConfigurationClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, __VA_ARGS__)
2593 #define emberAfOtaConfigurationClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, __VA_ARGS__)
2594 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2595 #define emberAfOtaConfigurationClusterFlush()
2596 #define emberAfOtaConfigurationClusterDebugExec(x)                                                                                 \
2597     if (emberAfPrintEnabled(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER))                                                             \
2598     {                                                                                                                              \
2599         x;                                                                                                                         \
2600     }
2601 #define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace)                                                          \
2602     emberAfPrintBuffer(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer), (len), (withSpace))
2603 #define emberAfOtaConfigurationClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER, (buffer))
2604 #else
2605 #define emberAfOtaConfigurationClusterPrint(...)
2606 #define emberAfOtaConfigurationClusterPrintln(...)
2607 #define emberAfOtaConfigurationClusterFlush()
2608 #define emberAfOtaConfigurationClusterDebugExec(x)
2609 #define emberAfOtaConfigurationClusterPrintBuffer(buffer, len, withSpace)
2610 #define emberAfOtaConfigurationClusterPrintString(buffer)
2611 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_OTA_CONFIGURATION_CLUSTER)
2612
2613 // Printing macros for cluster: MFGLIB Cluster
2614 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER)
2615 #define emberAfMfglibClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_MFGLIB_CLUSTER, __VA_ARGS__)
2616 #define emberAfMfglibClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_MFGLIB_CLUSTER, __VA_ARGS__)
2617 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2618 #define emberAfMfglibClusterFlush()
2619 #define emberAfMfglibClusterDebugExec(x)                                                                                           \
2620     if (emberAfPrintEnabled(EMBER_AF_PRINT_MFGLIB_CLUSTER))                                                                        \
2621     {                                                                                                                              \
2622         x;                                                                                                                         \
2623     }
2624 #define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace)                                                                    \
2625     emberAfPrintBuffer(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer), (len), (withSpace))
2626 #define emberAfMfglibClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_MFGLIB_CLUSTER, (buffer))
2627 #else
2628 #define emberAfMfglibClusterPrint(...)
2629 #define emberAfMfglibClusterPrintln(...)
2630 #define emberAfMfglibClusterFlush()
2631 #define emberAfMfglibClusterDebugExec(x)
2632 #define emberAfMfglibClusterPrintBuffer(buffer, len, withSpace)
2633 #define emberAfMfglibClusterPrintString(buffer)
2634 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_MFGLIB_CLUSTER)
2635
2636 // Printing macros for cluster: SL Works With All Hubs
2637 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER)
2638 #define emberAfSlWwahClusterPrint(...) emberAfPrint(EMBER_AF_PRINT_SL_WWAH_CLUSTER, __VA_ARGS__)
2639 #define emberAfSlWwahClusterPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SL_WWAH_CLUSTER, __VA_ARGS__)
2640 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2641 #define emberAfSlWwahClusterFlush()
2642 #define emberAfSlWwahClusterDebugExec(x)                                                                                           \
2643     if (emberAfPrintEnabled(EMBER_AF_PRINT_SL_WWAH_CLUSTER))                                                                       \
2644     {                                                                                                                              \
2645         x;                                                                                                                         \
2646     }
2647 #define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace)                                                                    \
2648     emberAfPrintBuffer(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer), (len), (withSpace))
2649 #define emberAfSlWwahClusterPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SL_WWAH_CLUSTER, (buffer))
2650 #else
2651 #define emberAfSlWwahClusterPrint(...)
2652 #define emberAfSlWwahClusterPrintln(...)
2653 #define emberAfSlWwahClusterFlush()
2654 #define emberAfSlWwahClusterDebugExec(x)
2655 #define emberAfSlWwahClusterPrintBuffer(buffer, len, withSpace)
2656 #define emberAfSlWwahClusterPrintString(buffer)
2657 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SL_WWAH_CLUSTER)
2658
2659 // Printing macros for Core
2660 // Prints messages for global flow of the receive/send
2661 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE)
2662 #define emberAfCorePrint(...) emberAfPrint(EMBER_AF_PRINT_CORE, __VA_ARGS__)
2663 #define emberAfCorePrintln(...) emberAfPrintln(EMBER_AF_PRINT_CORE, __VA_ARGS__)
2664 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2665 #define emberAfCoreFlush()
2666 #define emberAfCoreDebugExec(x)                                                                                                    \
2667     if (emberAfPrintEnabled(EMBER_AF_PRINT_CORE))                                                                                  \
2668     {                                                                                                                              \
2669         x;                                                                                                                         \
2670     }
2671 #define emberAfCorePrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CORE, (buffer), (len), (withSpace))
2672 #define emberAfCorePrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CORE, (buffer))
2673 #else
2674 #define emberAfCorePrint(...)
2675 #define emberAfCorePrintln(...)
2676 #define emberAfCoreFlush()
2677 #define emberAfCoreDebugExec(x)
2678 #define emberAfCorePrintBuffer(buffer, len, withSpace)
2679 #define emberAfCorePrintString(buffer)
2680 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CORE)
2681
2682 // Printing macros for Debug
2683 // Prints messages for random debugging
2684 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG)
2685 #define emberAfDebugPrint(...) emberAfPrint(EMBER_AF_PRINT_DEBUG, __VA_ARGS__)
2686 #define emberAfDebugPrintln(...) emberAfPrintln(EMBER_AF_PRINT_DEBUG, __VA_ARGS__)
2687 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2688 #define emberAfDebugFlush()
2689 #define emberAfDebugDebugExec(x)                                                                                                   \
2690     if (emberAfPrintEnabled(EMBER_AF_PRINT_DEBUG))                                                                                 \
2691     {                                                                                                                              \
2692         x;                                                                                                                         \
2693     }
2694 #define emberAfDebugPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_DEBUG, (buffer), (len), (withSpace))
2695 #define emberAfDebugPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_DEBUG, (buffer))
2696 #else
2697 #define emberAfDebugPrint(...)
2698 #define emberAfDebugPrintln(...)
2699 #define emberAfDebugFlush()
2700 #define emberAfDebugDebugExec(x)
2701 #define emberAfDebugPrintBuffer(buffer, len, withSpace)
2702 #define emberAfDebugPrintString(buffer)
2703 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_DEBUG)
2704
2705 // Printing macros for Application
2706 // Prints messages for application part
2707 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP)
2708 #define emberAfAppPrint(...) emberAfPrint(EMBER_AF_PRINT_APP, __VA_ARGS__)
2709 #define emberAfAppPrintln(...) emberAfPrintln(EMBER_AF_PRINT_APP, __VA_ARGS__)
2710 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2711 #define emberAfAppFlush()
2712 #define emberAfAppDebugExec(x)                                                                                                     \
2713     if (emberAfPrintEnabled(EMBER_AF_PRINT_APP))                                                                                   \
2714     {                                                                                                                              \
2715         x;                                                                                                                         \
2716     }
2717 #define emberAfAppPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_APP, (buffer), (len), (withSpace))
2718 #define emberAfAppPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_APP, (buffer))
2719 #else
2720 #define emberAfAppPrint(...)
2721 #define emberAfAppPrintln(...)
2722 #define emberAfAppFlush()
2723 #define emberAfAppDebugExec(x)
2724 #define emberAfAppPrintBuffer(buffer, len, withSpace)
2725 #define emberAfAppPrintString(buffer)
2726 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_APP)
2727
2728 // Printing macros for Attributes
2729 // Prints messages related to attributes
2730 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES)
2731 #define emberAfAttributesPrint(...) emberAfPrint(EMBER_AF_PRINT_ATTRIBUTES, __VA_ARGS__)
2732 #define emberAfAttributesPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ATTRIBUTES, __VA_ARGS__)
2733 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2734 #define emberAfAttributesFlush()
2735 #define emberAfAttributesDebugExec(x)                                                                                              \
2736     if (emberAfPrintEnabled(EMBER_AF_PRINT_ATTRIBUTES))                                                                            \
2737     {                                                                                                                              \
2738         x;                                                                                                                         \
2739     }
2740 #define emberAfAttributesPrintBuffer(buffer, len, withSpace)                                                                       \
2741     emberAfPrintBuffer(EMBER_AF_PRINT_ATTRIBUTES, (buffer), (len), (withSpace))
2742 #define emberAfAttributesPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ATTRIBUTES, (buffer))
2743 #else
2744 #define emberAfAttributesPrint(...)
2745 #define emberAfAttributesPrintln(...)
2746 #define emberAfAttributesFlush()
2747 #define emberAfAttributesDebugExec(x)
2748 #define emberAfAttributesPrintBuffer(buffer, len, withSpace)
2749 #define emberAfAttributesPrintString(buffer)
2750 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ATTRIBUTES)
2751
2752 // Printing macros for Reporting
2753 // Prints messages related to reporting
2754 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING)
2755 #define emberAfReportingPrint(...) emberAfPrint(EMBER_AF_PRINT_REPORTING, __VA_ARGS__)
2756 #define emberAfReportingPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REPORTING, __VA_ARGS__)
2757 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2758 #define emberAfReportingFlush()
2759 #define emberAfReportingDebugExec(x)                                                                                               \
2760     if (emberAfPrintEnabled(EMBER_AF_PRINT_REPORTING))                                                                             \
2761     {                                                                                                                              \
2762         x;                                                                                                                         \
2763     }
2764 #define emberAfReportingPrintBuffer(buffer, len, withSpace)                                                                        \
2765     emberAfPrintBuffer(EMBER_AF_PRINT_REPORTING, (buffer), (len), (withSpace))
2766 #define emberAfReportingPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_REPORTING, (buffer))
2767 #else
2768 #define emberAfReportingPrint(...)
2769 #define emberAfReportingPrintln(...)
2770 #define emberAfReportingFlush()
2771 #define emberAfReportingDebugExec(x)
2772 #define emberAfReportingPrintBuffer(buffer, len, withSpace)
2773 #define emberAfReportingPrintString(buffer)
2774 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REPORTING)
2775
2776 // Printing macros for Service discovery
2777 // Prints messages related to service discovery
2778 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY)
2779 #define emberAfServiceDiscoveryPrint(...) emberAfPrint(EMBER_AF_PRINT_SERVICE_DISCOVERY, __VA_ARGS__)
2780 #define emberAfServiceDiscoveryPrintln(...) emberAfPrintln(EMBER_AF_PRINT_SERVICE_DISCOVERY, __VA_ARGS__)
2781 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2782 #define emberAfServiceDiscoveryFlush()
2783 #define emberAfServiceDiscoveryDebugExec(x)                                                                                        \
2784     if (emberAfPrintEnabled(EMBER_AF_PRINT_SERVICE_DISCOVERY))                                                                     \
2785     {                                                                                                                              \
2786         x;                                                                                                                         \
2787     }
2788 #define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace)                                                                 \
2789     emberAfPrintBuffer(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer), (len), (withSpace))
2790 #define emberAfServiceDiscoveryPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_SERVICE_DISCOVERY, (buffer))
2791 #else
2792 #define emberAfServiceDiscoveryPrint(...)
2793 #define emberAfServiceDiscoveryPrintln(...)
2794 #define emberAfServiceDiscoveryFlush()
2795 #define emberAfServiceDiscoveryDebugExec(x)
2796 #define emberAfServiceDiscoveryPrintBuffer(buffer, len, withSpace)
2797 #define emberAfServiceDiscoveryPrintString(buffer)
2798 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_SERVICE_DISCOVERY)
2799
2800 // Printing macros for Registration
2801 // Prints messages related to registration
2802 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION)
2803 #define emberAfRegistrationPrint(...) emberAfPrint(EMBER_AF_PRINT_REGISTRATION, __VA_ARGS__)
2804 #define emberAfRegistrationPrintln(...) emberAfPrintln(EMBER_AF_PRINT_REGISTRATION, __VA_ARGS__)
2805 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2806 #define emberAfRegistrationFlush()
2807 #define emberAfRegistrationDebugExec(x)                                                                                            \
2808     if (emberAfPrintEnabled(EMBER_AF_PRINT_REGISTRATION))                                                                          \
2809     {                                                                                                                              \
2810         x;                                                                                                                         \
2811     }
2812 #define emberAfRegistrationPrintBuffer(buffer, len, withSpace)                                                                     \
2813     emberAfPrintBuffer(EMBER_AF_PRINT_REGISTRATION, (buffer), (len), (withSpace))
2814 #define emberAfRegistrationPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_REGISTRATION, (buffer))
2815 #else
2816 #define emberAfRegistrationPrint(...)
2817 #define emberAfRegistrationPrintln(...)
2818 #define emberAfRegistrationFlush()
2819 #define emberAfRegistrationDebugExec(x)
2820 #define emberAfRegistrationPrintBuffer(buffer, len, withSpace)
2821 #define emberAfRegistrationPrintString(buffer)
2822 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_REGISTRATION)
2823
2824 // Printing macros for ZDO (ZigBee Device Object)
2825 // Prints messages related to ZDO functionality
2826 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO)
2827 #define emberAfZdoPrint(...) emberAfPrint(EMBER_AF_PRINT_ZDO, __VA_ARGS__)
2828 #define emberAfZdoPrintln(...) emberAfPrintln(EMBER_AF_PRINT_ZDO, __VA_ARGS__)
2829 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2830 #define emberAfZdoFlush()
2831 #define emberAfZdoDebugExec(x)                                                                                                     \
2832     if (emberAfPrintEnabled(EMBER_AF_PRINT_ZDO))                                                                                   \
2833     {                                                                                                                              \
2834         x;                                                                                                                         \
2835     }
2836 #define emberAfZdoPrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_ZDO, (buffer), (len), (withSpace))
2837 #define emberAfZdoPrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_ZDO, (buffer))
2838 #else
2839 #define emberAfZdoPrint(...)
2840 #define emberAfZdoPrintln(...)
2841 #define emberAfZdoFlush()
2842 #define emberAfZdoDebugExec(x)
2843 #define emberAfZdoPrintBuffer(buffer, len, withSpace)
2844 #define emberAfZdoPrintString(buffer)
2845 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_ZDO)
2846
2847 // Printing macros for Custom messages (1)
2848 // Messages that can be used by the end developer
2849 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1)
2850 #define emberAfCustom1Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM1, __VA_ARGS__)
2851 #define emberAfCustom1Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM1, __VA_ARGS__)
2852 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2853 #define emberAfCustom1Flush()
2854 #define emberAfCustom1DebugExec(x)                                                                                                 \
2855     if (emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM1))                                                                               \
2856     {                                                                                                                              \
2857         x;                                                                                                                         \
2858     }
2859 #define emberAfCustom1PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM1, (buffer), (len), (withSpace))
2860 #define emberAfCustom1PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM1, (buffer))
2861 #else
2862 #define emberAfCustom1Print(...)
2863 #define emberAfCustom1Println(...)
2864 #define emberAfCustom1Flush()
2865 #define emberAfCustom1DebugExec(x)
2866 #define emberAfCustom1PrintBuffer(buffer, len, withSpace)
2867 #define emberAfCustom1PrintString(buffer)
2868 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM1)
2869
2870 // Printing macros for Custom messages (2)
2871 // Messages that can be used by the end developer
2872 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2)
2873 #define emberAfCustom2Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM2, __VA_ARGS__)
2874 #define emberAfCustom2Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM2, __VA_ARGS__)
2875 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2876 #define emberAfCustom2Flush()
2877 #define emberAfCustom2DebugExec(x)                                                                                                 \
2878     if (emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM2))                                                                               \
2879     {                                                                                                                              \
2880         x;                                                                                                                         \
2881     }
2882 #define emberAfCustom2PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM2, (buffer), (len), (withSpace))
2883 #define emberAfCustom2PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM2, (buffer))
2884 #else
2885 #define emberAfCustom2Print(...)
2886 #define emberAfCustom2Println(...)
2887 #define emberAfCustom2Flush()
2888 #define emberAfCustom2DebugExec(x)
2889 #define emberAfCustom2PrintBuffer(buffer, len, withSpace)
2890 #define emberAfCustom2PrintString(buffer)
2891 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM2)
2892
2893 // Printing macros for Custom messages (3)
2894 // Messages that can be used by the end developer
2895 #if defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3)
2896 #define emberAfCustom3Print(...) emberAfPrint(EMBER_AF_PRINT_CUSTOM3, __VA_ARGS__)
2897 #define emberAfCustom3Println(...) emberAfPrintln(EMBER_AF_PRINT_CUSTOM3, __VA_ARGS__)
2898 // Blocking IO is enabled for all serial ports, therefore flush calls are unnecessary.
2899 #define emberAfCustom3Flush()
2900 #define emberAfCustom3DebugExec(x)                                                                                                 \
2901     if (emberAfPrintEnabled(EMBER_AF_PRINT_CUSTOM3))                                                                               \
2902     {                                                                                                                              \
2903         x;                                                                                                                         \
2904     }
2905 #define emberAfCustom3PrintBuffer(buffer, len, withSpace) emberAfPrintBuffer(EMBER_AF_PRINT_CUSTOM3, (buffer), (len), (withSpace))
2906 #define emberAfCustom3PrintString(buffer) emberAfPrintString(EMBER_AF_PRINT_CUSTOM3, (buffer))
2907 #else
2908 #define emberAfCustom3Print(...)
2909 #define emberAfCustom3Println(...)
2910 #define emberAfCustom3Flush()
2911 #define emberAfCustom3DebugExec(x)
2912 #define emberAfCustom3PrintBuffer(buffer, len, withSpace)
2913 #define emberAfCustom3PrintString(buffer)
2914 #endif // defined(EMBER_AF_PRINT_ENABLE) && defined(EMBER_AF_PRINT_CUSTOM3)