Level Controllable Output

Macros
#define	ZB_HA_DEVICE_VER_LEVEL_CONTROLLABLE_OUTPUT   0
#define	ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_IN_CLUSTER_NUM   6
#define	ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_OUT_CLUSTER_NUM   0
#define	ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_CLUSTER_NUM
#define	ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_REPORT_ATTR_COUNT   (ZB_ZCL_LEVEL_CONTROL_REPORT_ATTR_COUNT + ZB_ZCL_ON_OFF_REPORT_ATTR_COUNT)
#define	ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_CVC_ATTR_COUNT   1
#define	ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_CLUSTER_LIST( cluster_list_name, basic_attr_list, identify_attr_list, scenes_attr_list, groups_attr_list, on_off_attr_list, level_control_attr_list)
	Declare cluster list for Level Controllable Output device. More...
#define	ZB_ZCL_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_SIMPLE_DESC( ep_name, ep_id, in_clust_num, out_clust_num)
#define	ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_EP(ep_name, ep_id, cluster_list)
	Declare endpoint for Level Controllable Output device. More...
#define	ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_CTX(device_ctx, ep_name)   ZBOSS_DECLARE_DEVICE_CTX_1_EP(device_ctx, ep_name)
	Declare application's device context for Level Control Switch device. More...

Detailed Description

Level Control device has 6 clusters (see spec 7.4.4):

• ZCL Identify cluster
  
• ZCL Basic cluster
  
• ZCL Scenes cluster
  
• ZCL Groups cluster
  
• ZCL On/Off cluster
  
• ZCL Level control cluster

Sample use Level Control device

Example

• Declaring clusters:

  /* Basic cluster attributes data */
  zb_uint8_t g_attr_basic_zcl_version = ZB_ZCL_BASIC_ZCL_VERSION_DEFAULT_VALUE;
  zb_uint8_t g_attr_basic_application_version = ZB_ZCL_BASIC_APPLICATION_VERSION_DEFAULT_VALUE;
  zb_uint8_t g_attr_basic_stack_version = ZB_ZCL_BASIC_STACK_VERSION_DEFAULT_VALUE;
  zb_uint8_t g_attr_basic_hw_version = ZB_ZCL_BASIC_HW_VERSION_DEFAULT_VALUE;
  zb_char_t g_attr_basic_manufacturer_name[] = ZB_ZCL_BASIC_MANUFACTURER_NAME_DEFAULT_VALUE;
  zb_char_t g_attr_basic_model_identifier[] = ZB_ZCL_BASIC_MODEL_IDENTIFIER_DEFAULT_VALUE;
  zb_char_t g_attr_basic_date_code[] = ZB_ZCL_BASIC_DATE_CODE_DEFAULT_VALUE;
  zb_uint8_t g_attr_basic_power_source = ZB_ZCL_BASIC_POWER_SOURCE_DEFAULT_VALUE;
  zb_char_t g_attr_basic_location_description[] = ZB_ZCL_BASIC_LOCATION_DESCRIPTION_DEFAULT_VALUE;
  zb_uint8_t g_attr_basic_physical_environment = ZB_ZCL_BASIC_PHYSICAL_ENVIRONMENT_DEFAULT_VALUE;
  zb_char_t g_attr_sw_build_id[] = ZB_ZCL_BASIC_SW_BUILD_ID_DEFAULT_VALUE;
  
  ZB_ZCL_DECLARE_BASIC_ATTRIB_LIST_EXT(basic_attr_list, &g_attr_basic_zcl_version, &g_attr_basic_application_version, &g_attr_basic_stack_version, &g_attr_basic_hw_version, &g_attr_basic_manufacturer_name, &g_attr_basic_model_identifier, &g_attr_basic_date_code, &g_attr_basic_power_source, &g_attr_basic_location_description, &g_attr_basic_physical_environment, &g_attr_sw_build_id);

  /* Identify cluster attributes data */
  zb_uint16_t g_attr_identify_identify_time = ZB_ZCL_IDENTIFY_IDENTIFY_TIME_DEFAULT_VALUE;
  /* Groups cluster attributes data */
  zb_uint8_t g_attr_groups_name_support = 0;
  /* Scenes cluster attributes data */
  zb_uint8_t g_attr_scenes_scene_count = ZB_ZCL_SCENES_SCENE_COUNT_DEFAULT_VALUE;
  zb_uint8_t g_attr_scenes_current_scene = ZB_ZCL_SCENES_CURRENT_SCENE_DEFAULT_VALUE;
  zb_uint16_t g_attr_scenes_current_group = ZB_ZCL_SCENES_CURRENT_GROUP_DEFAULT_VALUE;
  zb_uint8_t g_attr_scenes_scene_valid = ZB_ZCL_SCENES_SCENE_VALID_DEFAULT_VALUE;
  zb_uint8_t g_attr_scenes_name_support = 0;
  /* On/Off cluster attributes data */
  zb_bool_t g_attr_on_off_on_off = ZB_ZCL_ON_OFF_ON_OFF_DEFAULT_VALUE;
  zb_bool_t g_attr_on_off_global_scene_control = ZB_ZCL_ON_OFF_GLOBAL_SCENE_CONTROL_DEFAULT_VALUE;
  zb_uint16_t g_attr_on_off_on_time = ZB_ZCL_ON_OFF_ON_TIME_DEFAULT_VALUE;
  zb_uint16_t g_attr_on_off_off_wait_time = ZB_ZCL_ON_OFF_OFF_WAIT_TIME_DEFAULT_VALUE;
  
  /* Level Control cluster attributes data */
  zb_uint8_t g_attr_level_control_current_level = ZB_ZCL_LEVEL_CONTROL_CURRENT_LEVEL_DEFAULT_VALUE;
  zb_uint16_t g_attr_level_control_remaining_time = ZB_ZCL_LEVEL_CONTROL_REMAINING_TIME_DEFAULT_VALUE;
  
  zb_uint8_t g_attr_start_up_on_off;
  zb_uint8_t g_attr_start_up_current_level;
  zb_uint8_t g_attr_options = 0x01;//ZB_ZCL_LEVEL_CONTROL_OPTIONS_DEFAULT_VALUE;
  
  ZB_ZCL_DECLARE_LEVEL_CONTROL_ATTRIB_LIST_EXT(level_control_attr_list, &g_attr_level_control_current_level, &g_attr_level_control_remaining_time, &g_attr_start_up_current_level, &g_attr_options);
  
  ZB_ZCL_DECLARE_ON_OFF_ATTRIB_LIST_EXT_WITH_START_UP_ON_OFF(on_off_attr_list, &g_attr_on_off_on_off, &g_attr_on_off_global_scene_control, &g_attr_on_off_on_time, &g_attr_on_off_off_wait_time, &g_attr_start_up_on_off);
  
  ZB_ZCL_DECLARE_IDENTIFY_ATTRIB_LIST(identify_attr_list, &g_attr_identify_identify_time);
  ZB_ZCL_DECLARE_SCENES_ATTRIB_LIST(scenes_attr_list, &g_attr_scenes_scene_count, &g_attr_scenes_current_scene, &g_attr_scenes_current_group, &g_attr_scenes_scene_valid, &g_attr_scenes_name_support);
  ZB_ZCL_DECLARE_GROUPS_ATTRIB_LIST(groups_attr_list, &g_attr_groups_name_support);
  /********************* Declare device **************************/
  ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_CLUSTER_LIST(level_controllable_output_clusters, basic_attr_list, identify_attr_list, scenes_attr_list, groups_attr_list, on_off_attr_list, level_control_attr_list);
  ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_EP(level_controllable_output_ep, ENDPOINT_C, level_controllable_output_clusters);
  ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_CTX(device_ctx, level_controllable_output_ep);

• Registering device list:

    /* Register device list */
    ZB_AF_REGISTER_DEVICE_CTX(&device_ctx);
    ZB_AF_SET_ENDPOINT_HANDLER(ENDPOINT_C, zcl_specific_cluster_cmd_handler);
    ZB_ZCL_REGISTER_DEVICE_CB(test_device_interface_cb);

• Example of command handler:

  zb_uint8_t zcl_specific_cluster_cmd_handler(zb_uint8_t param)
  {
    zb_uint8_t ret = ZB_FALSE;
    zb_zcl_parsed_hdr_t cmd_info;
    zb_uint8_t lqi = ZB_MAC_LQI_UNDEFINED;
    zb_int8_t rssi = ZB_MAC_RSSI_UNDEFINED;
  
    TRACE_MSG(TRACE_APP1, "> zcl_specific_cluster_cmd_handler", (FMT__0));
  
    ZB_ZCL_COPY_PARSED_HEADER(param, &cmd_info);
  
    g_dst_addr = ZB_ZCL_PARSED_HDR_SHORT_DATA(&cmd_info).source.u.short_addr;
  
    ZB_ZCL_DEBUG_DUMP_HEADER(&cmd_info);
    TRACE_MSG(TRACE_APP3, "payload size: %i", (FMT__D, zb_buf_len(param)));
  
    zb_zdo_get_diag_data(g_dst_addr, &lqi, &rssi);
    TRACE_MSG(TRACE_APP3, "lqi %hd rssi %d", (FMT__H_H, lqi, rssi));
  
    if (cmd_info.cmd_direction == ZB_ZCL_FRAME_DIRECTION_TO_CLI)
    {
      TRACE_MSG(
          TRACE_ERROR,
          "Unsupported \"from server\" command direction",
          (FMT__0));
    }
  
    TRACE_MSG(TRACE_APP1, "< zcl_specific_cluster_cmd_handler", (FMT__0));
    return ret;
  }

  void test_device_interface_cb(zb_uint8_t param)
  {
  
    zb_zcl_device_callback_param_t *device_cb_param =
      ZB_BUF_GET_PARAM(param, zb_zcl_device_callback_param_t);
  
    TRACE_MSG(TRACE_APP1, "> test_device_interface_cb param %hd id %hd", (FMT__H_H,
        param, device_cb_param->device_cb_id));
  
    device_cb_param->status = RET_OK;
  
    switch (device_cb_param->device_cb_id)
    {
      case ZB_ZCL_SET_ATTR_VALUE_CB_ID:
        if (device_cb_param->cb_param.set_attr_value_param.cluster_id == ZB_ZCL_CLUSTER_ID_ON_OFF &&
            device_cb_param->cb_param.set_attr_value_param.attr_id == ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID)
        {
          if (device_cb_param->cb_param.set_attr_value_param.values.data8)
          {
            TRACE_MSG(TRACE_APP1, "set ON", (FMT__0));
  #ifdef ZB_USE_BUTTONS
            zb_osif_led_on(0);
  #endif
          }
          else
          {
            TRACE_MSG(TRACE_APP1, "set OFF", (FMT__0));
  #ifdef ZB_USE_BUTTONS
            zb_osif_led_off(0);
  #endif
          }
        }
        else if (device_cb_param->cb_param.set_attr_value_param.cluster_id == ZB_ZCL_CLUSTER_ID_LEVEL_CONTROL &&
                 device_cb_param->cb_param.set_attr_value_param.attr_id == ZB_ZCL_ATTR_LEVEL_CONTROL_START_UP_CURRENT_LEVEL_ID)
        {
  #ifdef ZB_USE_NVRAM
          if (device_cb_param->cb_param.set_attr_value_param.values.data8 != ZB_ZCL_LEVEL_CONTROL_START_UP_CURRENT_LEVEL_USE_PREVIOUS_VALUE)
          {
            g_attr_start_up_current_level = device_cb_param->cb_param.set_attr_value_param.values.data8;
          }
          else
          {
            zb_zcl_attr_t *attr_desc;
            attr_desc = zb_zcl_get_attr_desc_a(ENDPOINT_C, ZB_ZCL_CLUSTER_ID_LEVEL_CONTROL,
                                         ZB_ZCL_CLUSTER_SERVER_ROLE,ZB_ZCL_ATTR_LEVEL_CONTROL_CURRENT_LEVEL_ID);
            g_attr_start_up_current_level =  ZB_ZCL_GET_ATTRIBUTE_VAL_8(attr_desc);
          }
          zb_nvram_write_dataset(ZB_NVRAM_APP_DATA1);
  #endif
        }
        break;
  /* >>>> Scenes */
      case ZB_ZCL_SCENES_REMOVE_ALL_SCENES_CB_ID:
      {
        const zb_zcl_scenes_remove_all_scenes_req_t *remove_all_scenes_req = ZB_ZCL_DEVICE_CMD_PARAM_IN_GET(param, zb_zcl_scenes_remove_all_scenes_req_t);
        zb_uint8_t *remove_all_scenes_status = ZB_ZCL_DEVICE_CMD_PARAM_OUT_GET(param, zb_uint8_t);
        const zb_zcl_parsed_hdr_t *in_cmd_info = ZB_ZCL_DEVICE_CMD_PARAM_CMD_INFO(param);
  
        TRACE_MSG(TRACE_APP1, "ZB_ZCL_SCENES_REMOVE_ALL_SCENES_CB_ID: group_id 0x%x", (FMT__D, remove_all_scenes_req->group_id));
  
        if (!zb_aps_is_endpoint_in_group(
                   remove_all_scenes_req->group_id,
                   ZB_ZCL_PARSED_HDR_SHORT_DATA(in_cmd_info).dst_endpoint))
        {
          *remove_all_scenes_status = ZB_ZCL_STATUS_INVALID_FIELD;
        }
        else
        {
          test_device_scenes_remove_entries_by_group(remove_all_scenes_req->group_id);
          *remove_all_scenes_status = ZB_ZCL_STATUS_SUCCESS;
        }
      }
      break;
      case ZB_ZCL_SCENES_STORE_SCENE_CB_ID:
      {
        const zb_zcl_scenes_store_scene_req_t *store_scene_req = ZB_ZCL_DEVICE_CMD_PARAM_IN_GET(param, zb_zcl_scenes_store_scene_req_t);
        zb_uint8_t idx = 0xFF;
        zb_uint8_t *store_scene_status = ZB_ZCL_DEVICE_CMD_PARAM_OUT_GET(param, zb_uint8_t);
        const zb_zcl_parsed_hdr_t *in_cmd_info = ZB_ZCL_DEVICE_CMD_PARAM_CMD_INFO(param);
  
        TRACE_MSG(TRACE_APP1, "ZB_ZCL_SCENES_STORE_SCENE_CB_ID: group_id 0x%x scene_id 0x%hd", (FMT__D_H, store_scene_req->group_id, store_scene_req->scene_id));
  
        if (!zb_aps_is_endpoint_in_group(
                   store_scene_req->group_id,
                   ZB_ZCL_PARSED_HDR_SHORT_DATA(in_cmd_info).dst_endpoint))
        {
          *store_scene_status = ZB_ZCL_STATUS_INVALID_FIELD;
        }
        else
        {
          idx = test_device_scenes_get_entry(store_scene_req->group_id, store_scene_req->scene_id);
  
          if (idx != 0xFF)
          {
            if (scenes_table[idx].common.group_id != ZB_ZCL_SCENES_FREE_SCENE_TABLE_RECORD)
            {
              /* Update existing entry with current On/Off state */
              device_cb_param->status = RET_ALREADY_EXISTS;
              scenes_table[idx].onoff_state = g_attr_on_off_on_off;
              scenes_table[idx].current_level = g_attr_level_control_current_level;
              TRACE_MSG(TRACE_APP1, "update scene: entry idx %hd onoff_state %hd", (FMT__H_H, idx, scenes_table[idx].onoff_state));
            }
            else
            {
              /* Create new entry with empty name and 0 transition time */
              scenes_table[idx].common.group_id = store_scene_req->group_id;
              scenes_table[idx].common.scene_id = store_scene_req->scene_id;
              scenes_table[idx].common.transition_time = 0;
              scenes_table[idx].onoff_state = g_attr_on_off_on_off;
              scenes_table[idx].current_level = g_attr_level_control_current_level;
              TRACE_MSG(TRACE_APP1, "store new scene: entry idx %hd onoff_state %hd", (FMT__H_H, idx, scenes_table[idx].onoff_state));
            }
  
            *store_scene_status = ZB_ZCL_STATUS_SUCCESS;
          }
          else
          {
            *store_scene_status = ZB_ZCL_STATUS_INSUFF_SPACE;
          }
        }
      }
      break;
      case ZB_ZCL_SCENES_RECALL_SCENE_CB_ID:
      {
        const zb_zcl_scenes_recall_scene_req_t *recall_scene_req = ZB_ZCL_DEVICE_CMD_PARAM_IN_GET(param, zb_zcl_scenes_recall_scene_req_t);
        zb_uint8_t idx = 0xFF;
        zb_uint8_t *recall_scene_status = ZB_ZCL_DEVICE_CMD_PARAM_OUT_GET(param, zb_uint8_t);
  
        TRACE_MSG(TRACE_APP1, "ZB_ZCL_SCENES_REMOVE_SCENE_CB_ID: group_id 0x%x scene_id 0x%hd", (FMT__D_H, recall_scene_req->group_id, recall_scene_req->scene_id));
  
        idx = test_device_scenes_get_entry(recall_scene_req->group_id, recall_scene_req->scene_id);
  
        if (idx != 0xFF &&
            scenes_table[idx].common.group_id != ZB_ZCL_SCENES_FREE_SCENE_TABLE_RECORD)
        {
          /* Recall this entry */
          TRACE_MSG(TRACE_APP1, "recall scene: entry idx %hd onoff_state %hd transition_time 0x%x", (FMT__H_H_D, idx, scenes_table[idx].onoff_state, scenes_table[idx].common.transition_time));
          ZB_ZCL_SET_ATTRIBUTE(
            ENDPOINT_C,
            ZB_ZCL_CLUSTER_ID_ON_OFF,
            ZB_ZCL_CLUSTER_SERVER_ROLE,
            ZB_ZCL_ATTR_ON_OFF_ON_OFF_ID,
            &scenes_table[idx].onoff_state,
            ZB_FALSE);
          ZB_ZCL_SET_ATTRIBUTE(
            ENDPOINT_C,
            ZB_ZCL_CLUSTER_ID_LEVEL_CONTROL,
            ZB_ZCL_CLUSTER_SERVER_ROLE,
            ZB_ZCL_ATTR_LEVEL_CONTROL_CURRENT_LEVEL_ID,
            &scenes_table[idx].current_level,
            ZB_FALSE);
  
          *recall_scene_status = ZB_ZCL_STATUS_SUCCESS;
        }
        else
        {
          *recall_scene_status = ZB_ZCL_STATUS_NOT_FOUND;
        }
      }
      break;
      case ZB_ZCL_SCENES_INTERNAL_REMOVE_ALL_SCENES_ALL_ENDPOINTS_CB_ID:
      {
        const zb_zcl_scenes_remove_all_scenes_req_t *remove_all_scenes_req = ZB_ZCL_DEVICE_CMD_PARAM_IN_GET(param, zb_zcl_scenes_remove_all_scenes_req_t);
  
        TRACE_MSG(TRACE_APP1, "ZB_ZCL_SCENES_INTERNAL_REMOVE_ALL_SCENES_ALL_ENDPOINTS_CB_ID: group_id 0x%x", (FMT__D, remove_all_scenes_req->group_id));
  
        /* Have only one endpoint */
        test_device_scenes_remove_entries_by_group(remove_all_scenes_req->group_id);
      }
      break;
      case ZB_ZCL_SCENES_INTERNAL_REMOVE_ALL_SCENES_ALL_ENDPOINTS_ALL_GROUPS_CB_ID:
      {
        test_device_scenes_table_init();
      }
      break;
      /* <<<< Scenes */
      default:
        device_cb_param->status = RET_OK;
        break;
    }
  
    TRACE_MSG(TRACE_APP1, "< test_device_interface_cb %hd", (FMT__H, device_cb_param->status));
  }

  The complete set of Level Control device samples can be found in /application/HA_samples/level_control_output

Macro Definition Documentation

ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_CLUSTER_LIST

#define ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_CLUSTER_LIST	(		cluster_list_name,
			basic_attr_list,
			identify_attr_list,
			scenes_attr_list,
			groups_attr_list,
			on_off_attr_list,
			level_control_attr_list
	)

Declare cluster list for Level Controllable Output device.

Parameters

cluster_list_name	- cluster list variable name
basic_attr_list	- attribute list for Basic cluster
identify_attr_list	- attribute list for Identify cluster
scenes_attr_list	- attribute list for Scenes cluster
groups_attr_list	- attribute list for Groups cluster
on_off_attr_list	- attribute list for On/Off cluster
level_control_attr_list	- attribute list for Level Control cluster

ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_CTX

#define ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_CTX	(		device_ctx,
			ep_name
	)		ZBOSS_DECLARE_DEVICE_CTX_1_EP(device_ctx, ep_name)

Declare application's device context for Level Control Switch device.

Parameters

device_ctx	- device context variable
ep_name	- endpoint variable name

ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_EP

#define ZB_HA_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_EP	(		ep_name,
			ep_id,
			cluster_list
	)

Value:

ZB_ZCL_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_SIMPLE_DESC(ep_name,                                  \
   ep_id,                                                                                        \
   ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_IN_CLUSTER_NUM,                                               \
   ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_OUT_CLUSTER_NUM);                                             \
  ZBOSS_DEVICE_DECLARE_REPORTING_CTX(reporting_info## device_ctx_name,                           \
                                     ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_REPORT_ATTR_COUNT);         \
  ZBOSS_DEVICE_DECLARE_LEVEL_CONTROL_CTX(cvc_alarm_info## device_ctx_name,                       \
                                         ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_CVC_ATTR_COUNT);        \
  ZB_AF_DECLARE_ENDPOINT_DESC(ep_name, ep_id, ZB_AF_HA_PROFILE_ID,                               \
                              0,                                        \
                              NULL,                                     \
                          ZB_ZCL_ARRAY_SIZE(cluster_list, zb_zcl_cluster_desc_t), cluster_list,  \
                          (zb_af_simple_desc_1_1_t*)&simple_desc_##ep_name,                      \
                          ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_REPORT_ATTR_COUNT,                     \
                          reporting_info## device_ctx_name,                                      \
                          ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_CVC_ATTR_COUNT,                        \
                          cvc_alarm_info## device_ctx_name)

Declare endpoint for Level Controllable Output device.

Parameters

ep_name	- endpoint variable name
ep_id	- endpoint ID
cluster_list	- endpoint cluster list

ZB_HA_DEVICE_VER_LEVEL_CONTROLLABLE_OUTPUT

#define ZB_HA_DEVICE_VER_LEVEL_CONTROLLABLE_OUTPUT   0

< Level Controllable Output device version Level Controllable Output IN (server) clusters number

ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_CLUSTER_NUM

#define ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_CLUSTER_NUM

Value:

(   ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_IN_CLUSTER_NUM   \
   +  ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_OUT_CLUSTER_NUM)

ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_IN_CLUSTER_NUM

#define ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_IN_CLUSTER_NUM   6

Level Controllable Output OUT (client) clusters number

ZB_ZCL_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_SIMPLE_DESC

#define ZB_ZCL_DECLARE_LEVEL_CONTROLLABLE_OUTPUT_SIMPLE_DESC	(		ep_name,
			ep_id,
			in_clust_num,
			out_clust_num
	)

Value:

ZB_DECLARE_SIMPLE_DESC(in_clust_num, out_clust_num);                        \
  ZB_AF_SIMPLE_DESC_TYPE(in_clust_num, out_clust_num) simple_desc_##ep_name = \
  {                                                                           \
    ep_id,                                                                    \
    ZB_AF_HA_PROFILE_ID,                                                      \
    ZB_HA_LEVEL_CONTROLLABLE_OUTPUT_DEVICE_ID,                                \
    ZB_HA_DEVICE_VER_LEVEL_CONTROLLABLE_OUTPUT,                               \
    0,                                                                        \
    in_clust_num,                                                             \
    out_clust_num,                                                            \
    {                                                                         \
      ZB_ZCL_CLUSTER_ID_BASIC,                                                \
      ZB_ZCL_CLUSTER_ID_IDENTIFY,                                             \
      ZB_ZCL_CLUSTER_ID_SCENES,                                               \
      ZB_ZCL_CLUSTER_ID_GROUPS,                                               \
      ZB_ZCL_CLUSTER_ID_ON_OFF,                                               \
      ZB_ZCL_CLUSTER_ID_LEVEL_CONTROL                                         \
    }                                                                         \
  }