IAS Zone

Macros
#define	ZB_HA_IAS_ZONE_VER   0
#define	ZB_HA_DECLARE_IAS_ZONE_CLUSTER_LIST( cluster_list_name, basic_attr_list, identify_attr_list, ias_zone_attr_list, poll_ctrl_attr_list, power_config_attr_list, ota_upgrade_attr_list)
	Declare cluster list for IAS Zone. More...
#define	ZB_HA_DECLARE_IAS_ZONE_SIMPLE_DESC( ep_name, ep_id, in_clust_num, out_clust_num)
	Declare simple descriptor for IAS Zone. More...
#define	ZB_HA_DECLARE_IAS_ZONE_EP(ep_name, ep_id, cluster_list)
	Declare endpoint for IAS Ancillary Control Equipment. More...
#define	ZB_HA_DECLARE_IAS_ZONE_CTX(device_ctx, ep_name)   ZBOSS_DECLARE_DEVICE_CTX_1_EP(device_ctx, ep_name)
	Declare application's device context for IAS Zone device. More...

Detailed Description

IAS Zone has 6 clusters (see spec 7.8.3):

• ZCL Basic cluster
  
• ZCL Identify cluster
  
• ZCL IAS Zone cluster
  
• ZCL Poll Control cluster
  
• ZCL Power Configuration cluster
  
• ZCL OTA Upgrade cluster
  IAS Zone sample

Example

Declaring clusters

/**
 * Declaring attributes for each cluster
 */
 
/* Global cluster attributes data initiated into global device context */
ZB_ZCL_DECLARE_BASIC_ATTRIB_LIST_EXT(
  basic_attr_list,
  &g_device_ctx.basic_attr.zcl_version,
  &g_device_ctx.basic_attr.app_version,
  &g_device_ctx.basic_attr.stack_version,
  &g_device_ctx.basic_attr.hw_version,
  &g_device_ctx.basic_attr.mf_name,
  &g_device_ctx.basic_attr.model_id,
  &g_device_ctx.basic_attr.date_code,
  &g_device_ctx.basic_attr.power_source,
  &g_device_ctx.basic_attr.location_id,
  &g_device_ctx.basic_attr.ph_env,
  &g_device_ctx.basic_attr.sw_build_id);
 
/* Identify cluster attributes data initiated into global device context */
ZB_ZCL_DECLARE_IDENTIFY_ATTRIB_LIST(identify_attr_list,
  &g_device_ctx.identify_attr.identify_time);
 
/* IAS Zone cluster attributes data initiated into global device context */
ZB_ZCL_DECLARE_IAS_ZONE_ATTRIB_LIST_EXT(
  ias_zone_attr_list,
  &IZS_DEVICE_ZONE_STATE(),
  &g_device_ctx.zone_attr.zone_type,
  &g_device_ctx.zone_attr.zone_status,
  &g_device_ctx.zone_attr.number_of_zone_sens_levels_supported,
  &g_device_ctx.zone_attr.current_zone_sens_level,
  &IZS_DEVICE_CIE_ADDR(),
  &g_device_ctx.zone_attr.zone_id,
  &g_device_ctx.zone_attr.cie_short_addr,
  &g_device_ctx.zone_attr.cie_ep);
 
/* Poll control cluster attributes data initiated into global device context */
ZB_ZCL_DECLARE_POLL_CONTROL_ATTRIB_LIST(poll_ctrl_attr_list,
  &g_device_ctx.poll_control_attr.checkin_interval,
  &g_device_ctx.poll_control_attr.long_poll_interval,
  &g_device_ctx.poll_control_attr.short_poll_interval,
  &g_device_ctx.poll_control_attr.fast_poll_timeout,
  &g_device_ctx.poll_control_attr.checkin_interval_min,
  &g_device_ctx.poll_control_attr.long_poll_interval_min,
  &g_device_ctx.poll_control_attr.fast_poll_timeout_max);
 
/* Define 'bat_num' as empty in order to declare default battery set attributes. */
/* According to Table 3-17 of ZCL specification, defining 'bat_num' as 2 or 3 allows */
/* to declare battery set attributes for BATTERY2 and BATTERY3 */
#define bat_num
 
/* Power config cluster attributes data initiated into global device context */
ZB_ZCL_DECLARE_POWER_CONFIG_BATTERY_ATTRIB_LIST_EXT(
  power_config_attr_list,
  &g_device_ctx.pwr_cfg_attr.voltage,
  &g_device_ctx.pwr_cfg_attr.size,
  &g_device_ctx.pwr_cfg_attr.quantity,
  &g_device_ctx.pwr_cfg_attr.rated_voltage,
  &g_device_ctx.pwr_cfg_attr.alarm_mask,
  &g_device_ctx.pwr_cfg_attr.voltage_min_threshold,
  &g_device_ctx.pwr_cfg_attr.remaining,
  &g_device_ctx.pwr_cfg_attr.threshold1,
  &g_device_ctx.pwr_cfg_attr.threshold2,
  &g_device_ctx.pwr_cfg_attr.threshold3,
  &g_device_ctx.pwr_cfg_attr.min_threshold,
  &g_device_ctx.pwr_cfg_attr.percent_threshold1,
  &g_device_ctx.pwr_cfg_attr.percent_threshold2,
  &g_device_ctx.pwr_cfg_attr.percent_threshold3,
  &g_device_ctx.pwr_cfg_attr.alarm_state);
 
/* OTA cluster attributes declaration*/
#ifdef IZS_OTA
/* OTA cluster attributes data initiated into global device context */
ZB_ZCL_DECLARE_OTA_UPGRADE_ATTRIB_LIST(ota_upgrade_attr_list,
    &g_device_ctx.ota_attr.upgrade_server,
    &g_device_ctx.ota_attr.file_offset,
    &g_device_ctx.ota_attr.file_version,
    &g_device_ctx.ota_attr.stack_version,
    &g_device_ctx.ota_attr.downloaded_file_ver,
    &g_device_ctx.ota_attr.downloaded_stack_ver,
    &g_device_ctx.ota_attr.image_status,
    &g_device_ctx.ota_attr.manufacturer,
    &g_device_ctx.ota_attr.image_type,
    &g_device_ctx.ota_attr.min_block_reque,
    &g_device_ctx.ota_attr.image_stamp,
    &g_device_ctx.ota_attr.server_addr,
    &g_device_ctx.ota_attr.server_ep,
    IZS_INIT_OTA_HW_VERSION,
    IZS_OTA_IMAGE_BLOCK_DATA_SIZE_MAX,
    ZB_ZCL_OTA_UPGRADE_QUERY_TIMER_COUNT_DEF);
#else
zb_zcl_attr_t ota_upgrade_attr_list[] = { { ZB_ZCL_NULL_ID, 0, 0, NULL } };
#endif
 
/* WWAH cluster attributes declaration*/
#ifdef IZS_WWAH
ZB_ZCL_DECLARE_WWAH_ATTRIB_LIST(wwah_attr_list);
#else
zb_zcl_attr_t wwah_attr_list[] = { { ZB_ZCL_NULL_ID, 0, 0, NULL } };
#endif
 
/* Declare cluster list for a device */
#ifdef IZS_WWAH
IZS_DECLARE_IAS_ZONE_CLUSTER_LIST(
  cs_device_clusters,
  basic_attr_list,
  wwah_attr_list,
  identify_attr_list,
  ias_zone_attr_list,
  poll_ctrl_attr_list,
  power_config_attr_list,
  ota_upgrade_attr_list);
#else
IZS_DECLARE_IAS_ZONE_CLUSTER_LIST(
  cs_device_clusters,
  basic_attr_list,
  identify_attr_list,
  ias_zone_attr_list,
  poll_ctrl_attr_list,
  power_config_attr_list,
  ota_upgrade_attr_list);
#endif
 
/* Declare endpoint */
IZS_DECLARE_IAS_ZONE_EP(cs_device_ep, IZS_DEVICE_ENDPOINT, cs_device_clusters);
/* Declare application's device context for single-endpoint device */
ZB_HA_DECLARE_IAS_ZONE_CTX(izs_device_zcl_ctx, cs_device_ep);

Registering device list

  /* Register device ZCL context */
  ZB_AF_REGISTER_DEVICE_CTX(&izs_device_zcl_ctx);
  /* Register cluster commands handler for a specific endpoint */
  ZB_AF_SET_ENDPOINT_HANDLER(IZS_DEVICE_ENDPOINT, izs_zcl_cmd_handler);

Example of command handler

zb_uint8_t izs_zcl_cmd_handler(zb_uint8_t param)
{
  zb_bufid_t zcl_cmd_buf = param;
  zb_zcl_parsed_hdr_t *cmd_info = ZB_BUF_GET_PARAM(zcl_cmd_buf, zb_zcl_parsed_hdr_t);
  zb_uint8_t cmd_processed = ZB_FALSE;
  zb_uint8_t src_ep;
  zb_uint16_t src_addr;
 
  TRACE_MSG(TRACE_APP1, ">> izs_zcl_cmd_handler %i", (FMT__H, param));
  ZB_ZCL_DEBUG_DUMP_HEADER(cmd_info);
  TRACE_MSG(TRACE_APP1, "payload size: %i", (FMT__D, zb_buf_len(zcl_cmd_buf)));
 
  if (cmd_info->cmd_direction == ZB_ZCL_FRAME_DIRECTION_TO_SRV)
  {
   if (cmd_info->cluster_id == ZB_ZCL_CLUSTER_ID_POLL_CONTROL &&
       cmd_info->is_common_command)
    {
      switch (cmd_info->cmd_id)
      {
        case ZB_ZCL_CMD_WRITE_ATTRIB:
          {
            zb_zcl_write_attr_req_t *write_attr_req;
            /* Check that we receive the Write Attributes cmd for the checkin Interval AttrId
               If so, start checkin cycle */
            write_attr_req = (zb_zcl_write_attr_req_t*)zb_buf_begin(zcl_cmd_buf);
            if (ZB_ZCL_ATTR_POLL_CONTROL_CHECKIN_INTERVAL_ID == write_attr_req->attr_id)
            {
              if (0 != ZB_ZCL_ATTR_GET32(write_attr_req->attr_value))
              {
                TRACE_MSG(TRACE_APP2, "check in interval is set", (FMT__0));
                if (!g_device_ctx.check_in_started)
                {
                  zb_uint8_t canceled_param = 0;
 
                  TRACE_MSG(TRACE_APP2, "save addr and start check-in", (FMT__0));
                  /* Set Addr and EP for Poll control */
                  src_ep = ZB_ZCL_PARSED_HDR_SHORT_DATA(cmd_info).src_endpoint;
                  src_addr = ZB_ZCL_PARSED_HDR_SHORT_DATA(cmd_info).source.u.short_addr;
                  zb_zcl_poll_control_set_client_addr(IZS_DEVICE_ENDPOINT, src_addr, src_ep);
 
                  canceled_param = zb_zcl_poll_control_stop();
                  if (canceled_param)
                  {
                    TRACE_MSG(TRACE_APP2, "free canceled buffer %hd", (FMT__H, canceled_param));
                    zb_buf_free(canceled_param);
                  }
                  zb_buf_get_out_delayed(izs_go_on_guard);
                }
              }
              else
              {
                TRACE_MSG(TRACE_APP2, "mark check-in as not started", (FMT__0));
                g_device_ctx.check_in_started = 0;
              }
            }
          }
          break;
        default:
          /* TRACE_MSG(TRACE_APP1, "skip command %hd", (FMT__H, cmd_info->cmd_id)); */
          break;
      }
    }
    else if (cmd_info->cluster_id == ZB_ZCL_CLUSTER_ID_IAS_ZONE &&
             cmd_info->is_common_command)
    {
       switch (cmd_info->cmd_id)
       {
          case ZB_ZCL_CMD_WRITE_ATTRIB:
            {
               zb_zcl_write_attr_req_t *write_attr_req;
               /* Check that we receive the Write Attributes cmd for the CIE address
                  If so, start fast polling */
               write_attr_req = (zb_zcl_write_attr_req_t*)zb_buf_begin(zcl_cmd_buf);
               if (ZB_ZCL_ATTR_IAS_ZONE_IAS_CIE_ADDRESS_ID == write_attr_req->attr_id)
               {
#ifdef FAST_POLLING_DURING_COMMISSIONING
                 izs_start_fast_polling_for_commissioning(IZS_DEVICE_TURBO_POLL_AFTER_CIE_ADDR_DURATION * 1000l);
#else
                 ZDO_CTX().poll_update_delay = IZS_DEVICE_INITIAL_FAST_POLL_DURATION;
#endif /* FAST_POLLING_DURING_COMMISSIONING */
 
                 g_device_ctx.zone_attr.cie_short_addr = cmd_info->addr_data.common_data.source.u.short_addr;
                 g_device_ctx.zone_attr.cie_ep = cmd_info->addr_data.common_data.src_endpoint;
 
                 TRACE_MSG(TRACE_APP1,
                          "CIE address is updated. New cie_short_addr = 0x%x, cie_ep = 0x%x ",
                          (FMT__H_H, g_device_ctx.zone_attr.cie_short_addr, g_device_ctx.zone_attr.cie_ep));
 
                 if (g_device_ctx.enrollment_method == ZB_ZCL_WWAH_ENROLLMENT_MODE_AUTO_ENROLL_REQUEST)
                 {
                   TRACE_MSG(TRACE_APP1, "auto enroll request mode - send EnrollRequest", (FMT__0));
                   g_device_ctx.enroll_req_generated = ZB_TRUE;
 
                   zb_buf_get_out_delayed(izs_send_enroll_req);
                 }
               }
             }
             break;
          default:
            break;
       }
    } else
    if (cmd_info->cluster_id == ZB_ZCL_CLUSTER_ID_IAS_ZONE &&
        !cmd_info->is_common_command)
    {
      switch (cmd_info->cmd_id)
      {
        case ZB_ZCL_CMD_IAS_ZONE_ZONE_ENROLL_RESPONSE_ID:
        {
          TRACE_MSG(TRACE_APP1, "ZB_ZCL_CMD_IAS_ZONE_ZONE_ENROLL_RESPONSE_ID", (FMT__0));
 
          src_ep = ZB_ZCL_PARSED_HDR_SHORT_DATA(cmd_info).src_endpoint;
          src_addr = ZB_ZCL_PARSED_HDR_SHORT_DATA(cmd_info).source.u.short_addr;
 
          /* Note: after a call to this function buffer becomes invalid */
          cmd_processed = zb_zcl_process_ias_zone_specific_commands(param);
          TRACE_MSG(TRACE_APP1, "cmd_processed %hd", (FMT__H, cmd_processed));
 
          if (IZS_DEVICE_IS_ENROLLED())
          {
            TRACE_MSG(TRACE_APP1, "device is enrolled, save data", (FMT__0));
            /* set cie short addr and ep values; correct values maybe
             * already set in izs_zcl_cmd_handler() */
            g_device_ctx.zone_attr.cie_ep = src_ep;
            g_device_ctx.zone_attr.cie_short_addr = src_addr;
 
            zb_zcl_poll_control_set_client_addr(IZS_DEVICE_ENDPOINT, src_addr, src_ep);
#ifdef ZB_USE_NVRAM
            /* If we fail, trace is given and assertion is triggered */
            (void)zb_nvram_write_dataset(ZB_NVRAM_HA_DATA);
#endif
 
            zb_buf_get_out_delayed(izs_go_on_guard);
 
#ifdef IZS_OTA
            izs_check_and_get_ota_server(0);
#endif
 
#ifdef FAST_POLLING_DURING_COMMISSIONING
            izs_start_fast_polling_for_commissioning(IZS_DEVICE_TURBO_POLL_AFTER_ENROLL_DURATION * 1000l);
#endif /* FAST_POLLING_DURING_COMMISSIONING */
 
            /* force a ZoneStatusChange in case of silent tamper or motion alarms */
            ZB_SCHEDULE_APP_ALARM(izs_read_sensor_status, 0, (ZB_TIME_ONE_SECOND>>1));
          }
          break;
        }
 
        default:
          TRACE_MSG(TRACE_APP1, "skip command %hd", (FMT__H, cmd_info->cmd_id));
          break;
      }
    }
  }
 
  TRACE_MSG(TRACE_APP1, "<< izs_zcl_cmd_handler processed %hd", (FMT__H, cmd_processed));
  return cmd_processed;
}

Macro Definition Documentation

ZB_HA_DECLARE_IAS_ZONE_CLUSTER_LIST

#define ZB_HA_DECLARE_IAS_ZONE_CLUSTER_LIST	(		cluster_list_name,
			basic_attr_list,
			identify_attr_list,
			ias_zone_attr_list,
			poll_ctrl_attr_list,
			power_config_attr_list,
			ota_upgrade_attr_list
	)

Declare cluster list for IAS Zone.

Parameters

cluster_list_name	[IN] - cluster list variable name.
basic_attr_list	[IN] - attribute list for Basic cluster.
identify_attr_list	[IN] - attribute list for Identify cluster.
ias_zone_attr_list	[IN] - attribute list for IAS Zone cluster.
poll_ctrl_attr_list	[IN] - attribute list for Poll Control cluster.
power_config_attr_list	[IN] - attribute list for Power configuration cluster.
ota_upgrade_attr_list	[IN] - attribute list for Over The Air cluster.

ZB_HA_DECLARE_IAS_ZONE_CTX

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

Declare application's device context for IAS Zone device.

Parameters

device_ctx	- device context variable
ep_name	- endpoint variable name

ZB_HA_DECLARE_IAS_ZONE_EP

#define ZB_HA_DECLARE_IAS_ZONE_EP	(		ep_name,
			ep_id,
			cluster_list
	)

Value:

      ZB_HA_DECLARE_IAS_ZONE_SIMPLE_DESC(                       \
          ep_name,                                              \
          ep_id,                                                \
          ZB_HA_IAS_ZONE_IN_CLUSTER_NUM,                        \
          ZB_HA_IAS_ZONE_OUT_CLUSTER_NUM);                      \
  ZBOSS_DEVICE_DECLARE_REPORTING_CTX(reporting_info## device_ctx_name,  \
                                     ZB_HA_IAS_ZONE_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_IAS_ZONE_REPORT_ATTR_COUNT, reporting_info## device_ctx_name, \
    0, NULL)

Declare endpoint for IAS Ancillary Control Equipment.

Parameters

ep_name	[IN] - endpoint variable name.
ep_id	[IN] - endpoint ID.
cluster_list	[IN] - endpoint cluster list.

ZB_HA_DECLARE_IAS_ZONE_SIMPLE_DESC

#define ZB_HA_DECLARE_IAS_ZONE_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_IAS_ZONE_ID,                                      \
        ZB_HA_IAS_ZONE_VER,                                     \
        0,                                                      \
        in_clust_num,                                           \
        out_clust_num,                                          \
        {                                                       \
          ZB_ZCL_CLUSTER_ID_BASIC,                              \
          ZB_ZCL_CLUSTER_ID_IDENTIFY,                           \
          ZB_ZCL_CLUSTER_ID_IAS_ZONE,                           \
          ZB_ZCL_CLUSTER_ID_POLL_CONTROL,                       \
          ZB_ZCL_CLUSTER_ID_POWER_CONFIG,                       \
          ZB_ZCL_CLUSTER_ID_OTA_UPGRADE                         \
        }                                                       \
      }

Declare simple descriptor for IAS Zone.

Parameters

ep_name	- endpoint variable name.
ep_id	[IN] - endpoint ID.
in_clust_num	[IN] - number of supported input clusters.
out_clust_num	[IN] - number of supported output clusters.

Note

in_clust_num, out_clust_num should be defined by numeric constants, not variables or any definitions, because these values are used to form simple descriptor type name.

ZB_HA_IAS_ZONE_VER

#define ZB_HA_IAS_ZONE_VER   0

HA IAS Zone device version