Window Covering

Macros
#define	ZB_HA_DEVICE_VER_WINDOW_COVERING   0
#define	ZB_HA_DECLARE_WINDOW_COVERING_CLUSTER_LIST( cluster_list_name, basic_attr_list, identify_attr_list, groups_attr_list, scenes_attr_list, window_covering_attr_list)
	Declare cluster list for window covering device. More...
#define	ZB_ZCL_DECLARE_WINDOW_COVERING_SIMPLE_DESC(ep_name, ep_id, in_clust_num, out_clust_num)
	Declare simple descriptor for window covering device. More...
#define	ZB_HA_DECLARE_WINDOW_COVERING_EP(ep_name, ep_id, cluster_list)
	Declare endpoint for window covering device. More...
#define	ZB_HA_DECLARE_WINDOW_COVERING_CTX(device_ctx, ep_name)   ZBOSS_DECLARE_DEVICE_CTX_1_EP(device_ctx, ep_name)
	Declare application's device context for Window Covering device. More...

Detailed Description

Window Covering device has 5 clusters (see spec 7.6.3):

• ZCL Identify cluster
  
• ZCL Basic cluster
  
• ZCL Window Covering cluster
  
• ZCL Scenes cluster
  
• ZCL Groups cluster

Window Covering device sample

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;
  /* Window Covering cluster attributes data */
  zb_uint8_t g_attr_window_covering_window_covering_type = ZB_ZCL_WINDOW_COVERING_WINDOW_COVERING_TYPE_DEFAULT_VALUE;
  zb_uint8_t g_attr_window_covering_config_status = ZB_ZCL_WINDOW_COVERING_CONFIG_STATUS_DEFAULT_VALUE;
  zb_uint8_t g_attr_window_covering_current_position_lift_percentage = ZB_ZCL_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE_DEFAULT_VALUE;
  zb_uint8_t g_attr_window_covering_current_position_tilt_percentage = 0x32;//ZB_ZCL_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE_DEFAULT_VALUE;
  zb_uint16_t g_attr_window_covering_installed_open_limit_lift = ZB_ZCL_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_LIFT_DEFAULT_VALUE;
  zb_uint16_t g_attr_window_covering_installed_closed_limit_lift = ZB_ZCL_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_LIFT_DEFAULT_VALUE;
  zb_uint16_t g_attr_window_covering_installed_open_limit_tilt = ZB_ZCL_WINDOW_COVERING_INSTALLED_OPEN_LIMIT_TILT_DEFAULT_VALUE;
  zb_uint16_t g_attr_window_covering_installed_closed_limit_tilt = ZB_ZCL_WINDOW_COVERING_INSTALLED_CLOSED_LIMIT_TILT_DEFAULT_VALUE;
  zb_uint8_t g_attr_window_covering_mode = ZB_ZCL_WINDOW_COVERING_MODE_DEFAULT_VALUE;
  ZB_ZCL_DECLARE_IDENTIFY_ATTRIB_LIST(identify_attr_list, &g_attr_identify_identify_time);
  ZB_ZCL_DECLARE_GROUPS_ATTRIB_LIST(groups_attr_list, &g_attr_groups_name_support);
  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_WINDOW_COVERING_CLUSTER_ATTRIB_LIST(window_covering_attr_list, &g_attr_window_covering_window_covering_type, &g_attr_window_covering_config_status, &g_attr_window_covering_current_position_lift_percentage, &g_attr_window_covering_current_position_tilt_percentage, &g_attr_window_covering_installed_open_limit_lift, &g_attr_window_covering_installed_closed_limit_lift, &g_attr_window_covering_installed_open_limit_tilt, &g_attr_window_covering_installed_closed_limit_tilt, &g_attr_window_covering_mode);
  /********************* Declare device **************************/
  ZB_HA_DECLARE_WINDOW_COVERING_CLUSTER_LIST(window_covering_clusters, basic_attr_list, identify_attr_list, groups_attr_list, scenes_attr_list, window_covering_attr_list);
  ZB_HA_DECLARE_WINDOW_COVERING_EP(window_covering_ep, ENDPOINT_C, window_covering_clusters);
  ZB_HA_DECLARE_WINDOW_COVERING_CTX(device_ctx, window_covering_ep);

• Registering device list:

   /* Register device list */
   ZB_AF_REGISTER_DEVICE_CTX(&device_ctx);
   ZB_AF_SET_ENDPOINT_HANDLER(ZB_OUTPUT_ENDPOINT, 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_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 ZB_FALSE;
  }

  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
   }
   }
   break;
   case ZB_ZCL_WINDOW_COVERING_UP_OPEN_CB_ID:
   {
   zb_uint8_t lift_percentage_val = 0x00;
   zb_uint8_t tilt_percentage_val = 0x00;
   
   ZVUNUSED(zb_zcl_set_attr_val(ENDPOINT_C,
   ZB_ZCL_CLUSTER_ID_WINDOW_COVERING,
   ZB_ZCL_CLUSTER_SERVER_ROLE,
   ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE_ID,
   &lift_percentage_val,
   ZB_FALSE));
   
   ZVUNUSED(zb_zcl_set_attr_val(ENDPOINT_C,
   ZB_ZCL_CLUSTER_ID_WINDOW_COVERING,
   ZB_ZCL_CLUSTER_SERVER_ROLE,
   ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE_ID,
   &tilt_percentage_val,
   ZB_FALSE));
   break;
   }
   case ZB_ZCL_WINDOW_COVERING_DOWN_CLOSE_CB_ID:
   {
   zb_uint8_t lift_percentage_val = 0x64;
   zb_uint8_t tilt_percentage_val = 0x64;
   
   ZVUNUSED(zb_zcl_set_attr_val(ENDPOINT_C,
   ZB_ZCL_CLUSTER_ID_WINDOW_COVERING,
   ZB_ZCL_CLUSTER_SERVER_ROLE,
   ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE_ID,
   &lift_percentage_val,
   ZB_FALSE));
   
   ZVUNUSED(zb_zcl_set_attr_val(ENDPOINT_C,
   ZB_ZCL_CLUSTER_ID_WINDOW_COVERING,
   ZB_ZCL_CLUSTER_SERVER_ROLE,
   ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE_ID,
   &tilt_percentage_val,
   ZB_FALSE));
   break;
   }
   case ZB_ZCL_WINDOW_COVERING_STOP_CB_ID:
   break;
   case ZB_ZCL_WINDOW_COVERING_GO_TO_LIFT_PERCENTAGE_CB_ID:
   {
   const zb_zcl_go_to_lift_percentage_req_t *lift_percentage = ZB_ZCL_DEVICE_CMD_PARAM_IN_GET(param, zb_zcl_go_to_lift_percentage_req_t);
   zb_zcl_attr_t *attr_desc = zb_zcl_get_attr_desc_a(ENDPOINT_C,
   ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ZB_ZCL_CLUSTER_SERVER_ROLE, ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE_ID);
   if (attr_desc)
   {
   ZVUNUSED(zb_zcl_set_attr_val(ENDPOINT_C,
   ZB_ZCL_CLUSTER_ID_WINDOW_COVERING,
   ZB_ZCL_CLUSTER_SERVER_ROLE,
   ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE_ID,
   (zb_uint8_t *)&(lift_percentage->percentage_lift_value),
   ZB_FALSE));
   }
   break;
   }
   case ZB_ZCL_WINDOW_COVERING_GO_TO_TILT_PERCENTAGE_CB_ID:
   {
   const zb_zcl_go_to_tilt_percentage_req_t *tilt_percentage = ZB_ZCL_DEVICE_CMD_PARAM_IN_GET(param, zb_zcl_go_to_tilt_percentage_req_t);
   zb_zcl_attr_t *attr_desc = zb_zcl_get_attr_desc_a(ENDPOINT_C,
   ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, ZB_ZCL_CLUSTER_SERVER_ROLE, ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE_ID);
   if (attr_desc)
   {
   ZVUNUSED(zb_zcl_set_attr_val(ENDPOINT_C,
   ZB_ZCL_CLUSTER_ID_WINDOW_COVERING,
   ZB_ZCL_CLUSTER_SERVER_ROLE,
   ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE_ID,
   (zb_uint8_t *)&(tilt_percentage->percentage_tilt_value),
   ZB_FALSE));
   }
   break;
   }
   /* >>>> Scenes */
   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].lift_percentage_state = g_attr_window_covering_current_position_lift_percentage;
   scenes_table[idx].tilt_percentage_state = g_attr_window_covering_current_position_tilt_percentage;
   }
   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].lift_percentage_state = g_attr_window_covering_current_position_lift_percentage;
   scenes_table[idx].tilt_percentage_state = g_attr_window_covering_current_position_tilt_percentage;
   }
   
   *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_RECALL_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 */
   ZB_ZCL_SET_ATTRIBUTE(
   ENDPOINT_C,
   ZB_ZCL_CLUSTER_ID_WINDOW_COVERING,
   ZB_ZCL_CLUSTER_SERVER_ROLE,
   ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_LIFT_PERCENTAGE_ID,
   &scenes_table[idx].lift_percentage_state,
   ZB_FALSE);
   ZB_ZCL_SET_ATTRIBUTE(
   ENDPOINT_C,
   ZB_ZCL_CLUSTER_ID_WINDOW_COVERING,
   ZB_ZCL_CLUSTER_SERVER_ROLE,
   ZB_ZCL_ATTR_WINDOW_COVERING_CURRENT_POSITION_TILT_PERCENTAGE_ID,
   &scenes_table[idx].tilt_percentage_state,
   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_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));
  }

Macro Definition Documentation

ZB_HA_DECLARE_WINDOW_COVERING_CLUSTER_LIST

#define ZB_HA_DECLARE_WINDOW_COVERING_CLUSTER_LIST	(		cluster_list_name,
			basic_attr_list,
			identify_attr_list,
			groups_attr_list,
			scenes_attr_list,
			window_covering_attr_list
	)

Declare cluster list for window covering 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
groups_attr_list	- attribute list for Groups cluster
scenes_attr_list	- attribute list for Scenes cluster
window_covering_attr_list	- attribute list for Window covering cluster

ZB_HA_DECLARE_WINDOW_COVERING_CTX

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

Declare application's device context for Window Covering device.

Parameters

device_ctx	- device context variable
ep_name	- endpoint variable name

ZB_HA_DECLARE_WINDOW_COVERING_EP

#define ZB_HA_DECLARE_WINDOW_COVERING_EP	(		ep_name,
			ep_id,
			cluster_list
	)

Value:

 ZB_ZCL_DECLARE_WINDOW_COVERING_SIMPLE_DESC(ep_name, ep_id, \
 ZB_HA_WINDOW_COVERING_IN_CLUSTER_NUM, ZB_HA_WINDOW_COVERING_OUT_CLUSTER_NUM); \
 ZBOSS_DEVICE_DECLARE_REPORTING_CTX(reporting_info## device_ctx_name, \
 ZB_HA_WINDOW_COVERING_REPORT_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_WINDOW_COVERING_REPORT_ATTR_COUNT, reporting_info## device_ctx_name, \
 0, NULL) /* No CVC ctx */

Declare endpoint for window covering device.

Parameters

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

ZB_HA_DEVICE_VER_WINDOW_COVERING

#define ZB_HA_DEVICE_VER_WINDOW_COVERING   0

Window covering device version

ZB_ZCL_DECLARE_WINDOW_COVERING_SIMPLE_DESC

#define ZB_ZCL_DECLARE_WINDOW_COVERING_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_WINDOW_COVERING_DEVICE_ID, \
 ZB_HA_DEVICE_VER_WINDOW_COVERING, \
 0, \
 in_clust_num, \
 out_clust_num, \
 { \
 ZB_ZCL_CLUSTER_ID_BASIC, \
 ZB_ZCL_CLUSTER_ID_IDENTIFY, \
 ZB_ZCL_CLUSTER_ID_WINDOW_COVERING, \
 ZB_ZCL_CLUSTER_ID_SCENES, \
 ZB_ZCL_CLUSTER_ID_GROUPS \
 } \
 }

Declare simple descriptor for window covering device.

Parameters

ep_name	- endpoint variable name
ep_id	- endpoint ID
in_clust_num	- number of supported input clusters
out_clust_num	- number of supported output clusters