zcl.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2019 Digi International Inc.,
 * All rights not expressly granted are reserved.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Digi International Inc., 9350 Excelsior Blvd., Suite 700, Hopkins, MN 55343
 * ===========================================================================
 */

#ifndef __ZIGBEE_ZCL_H
#define __ZIGBEE_ZCL_H

#include "xbee/platform.h"          // platform-specific data types
#include "wpan/aps.h"
#include "zigbee/zcl_types.h"

XBEE_BEGIN_DECLS

#define ZCL_CLUST_BASIC                      0x0000
#define ZCL_CLUST_POWER_CONFIG               0x0001
#define ZCL_CLUST_DEVICE_TEMP_CONFIG         0x0002
#define ZCL_CLUST_IDENTIFY                   0x0003
#define ZCL_CLUST_GROUPS                     0x0004
#define ZCL_CLUST_SCENES                     0x0005
#define ZCL_CLUST_ONOFF                      0x0006
#define ZCL_CLUST_ONOFF_SWITCH_CONFIG        0x0007
#define ZCL_CLUST_LEVEL_CONTROL              0x0008
#define ZCL_CLUST_ALARMS                     0x0009
#define ZCL_CLUST_TIME                       0x000a
#define ZCL_CLUST_RSSI_LOCATION              0x000b
#define ZCL_CLUST_ANALOG_IN                  0x000c
#define ZCL_CLUST_ANALOG_OUT                 0x000d
#define ZCL_CLUST_ANALOG_VALUE               0x000e
#define ZCL_CLUST_BINARY_IN                  0x000f
#define ZCL_CLUST_BINARY_OUT                 0x0010
#define ZCL_CLUST_BINARY_VALUE               0x0011
#define ZCL_CLUST_MULTI_IN                   0x0012
#define ZCL_CLUST_MULTI_OUT                  0x0013
#define ZCL_CLUST_MULTI_VALUE                0x0014
#define ZCL_CLUST_COMMISSIONING              0x0015

#define ZCL_CLUST_SHADE_CONFIG               0x0100

#define ZCL_CLUST_PUMP_CONFIG                0x0200
#define ZCL_CLUST_THERMOSTAT                 0x0201
#define ZCL_CLUST_FAN_CONTROL                0x0202
#define ZCL_CLUST_DEHUMIDIFY_CONTROL         0x0203
#define ZCL_CLUST_THERMOSTAT_UI_CONFIG       0x0204

#define ZCL_CLUST_COLOR_CONTROL              0x0300
#define ZCL_CLUST_BALLAST_CONFIG             0x0301

#define ZCL_CLUST_ILLUM_MEASURE              0x0400
#define ZCL_CLUST_ILLUM_LEVEL_SENSING        0x0401
#define ZCL_CLUST_TEMP_MEASURE               0x0402
#define ZCL_CLUST_PRESSURE_MEASURE           0x0403
#define ZCL_CLUST_FLOW_MEASURE               0x0404
#define ZCL_CLUST_HUMIDITY_MEASURE           0x0405
#define ZCL_CLUST_OCCUPANCY_SENSING          0x0406

#define ZCL_CLUST_IAS_ZONE                   0x0500
#define ZCL_CLUST_IAS_ACE                    0x0501
#define ZCL_CLUST_IAS_WD                     0x0502

#define ZCL_CLUST_GENERIC_TUNNEL             0x0600
#define ZCL_CLUST_BACNET_TUNNEL              0x0601
#define ZCL_CLUST_BACNET_REG_ANALOG_IN       0x0602
#define ZCL_CLUST_BACNET_EXT_ANALOG_IN       0x0603
#define ZCL_CLUST_BACNET_REG_ANALOG_OUT      0x0604
#define ZCL_CLUST_BACNET_EXT_ANALOG_OUT      0x0605
#define ZCL_CLUST_BACNET_REG_ANALOG_VALUE    0x0606
#define ZCL_CLUST_BACNET_EXT_ANALOG_VALUE    0x0607
#define ZCL_CLUST_BACNET_REG_BINARY_IN       0x0608
#define ZCL_CLUST_BACNET_EXT_BINARY_IN       0x0609
#define ZCL_CLUST_BACNET_REG_BINARY_OUT      0x060a
#define ZCL_CLUST_BACNET_EXT_BINARY_OUT      0x060b
#define ZCL_CLUST_BACNET_REG_BINARY_VALUE    0x060c
#define ZCL_CLUST_BACNET_EXT_BINARY_VALUE    0x060d
#define ZCL_CLUST_BACNET_REG_MULTI_IN        0x060e
#define ZCL_CLUST_BACNET_EXT_MULTI_IN        0x060f
#define ZCL_CLUST_BACNET_REG_MULTI_OUT       0x0610
#define ZCL_CLUST_BACNET_EXT_MULTI_OUT       0x0611
#define ZCL_CLUST_BACNET_REG_MULTI_VALUE     0x0612
#define ZCL_CLUST_BACNET_EXT_MULTI_VALUE     0x0613


//
// General ZCL Frame Format
// 3 or 5-byte ZCL header followed by variable-length payload
//

typedef XBEE_PACKED(zcl_header_common_t, {
   uint8_t  sequence;
   uint8_t  command;
   uint8_t  payload[1];    
}) zcl_header_common_t;

typedef XBEE_PACKED(zcl_header_t, {
   uint8_t  frame_control;
   union {
      XBEE_PACKED(, {
         uint16_t             mfg_code_le;
         zcl_header_common_t  common;
      }) mfg;              
      XBEE_PACKED(, {
         zcl_header_common_t  common;
      }) std;              
   } type;
}) zcl_header_t;

typedef XBEE_PACKED(zcl_header_response_t, {
   union {
      XBEE_PACKED(, {
         uint8_t     frame_control;
         uint16_t    mfg_code_le;
      }) mfg;
      XBEE_PACKED(, {
         uint16_t    dummy;
         uint8_t     frame_control;
      }) std;
   } u;
   uint8_t                 sequence;
   uint8_t                 command;
}) zcl_header_response_t;

typedef XBEE_PACKED(zcl_header_withmfg_t, {
   uint8_t  frame_control;
   uint16_t mfg_code_le;
   uint8_t  sequence;
   uint8_t  command;
}) zcl_header_withmfg_t;

typedef XBEE_PACKED(zcl_header_nomfg_t, {
   uint8_t  frame_control;
   uint8_t  sequence;
   uint8_t  command;
}) zcl_header_nomfg_t;

#define ZCL_FRAME_TYPE_MASK         0x03
#define ZCL_FRAME_TYPE_PROFILE      0x00
#define ZCL_FRAME_TYPE_CLUSTER      0x01
#define ZCL_FRAME_TYPE_RESERVED1    0x02
#define ZCL_FRAME_TYPE_RESERVED2    0x03

#define ZCL_FRAME_GENERAL           0x00
#define ZCL_FRAME_MFG_SPECIFIC      0x04

#define ZCL_FRAME_DIRECTION         0x08
#define ZCL_FRAME_CLIENT_TO_SERVER  0
#define ZCL_FRAME_SERVER_TO_CLIENT  ZCL_FRAME_DIRECTION

#define ZCL_FRAME_DISABLE_DEF_RESP  0x10
#define ZCL_FRAME_RESERVED_BITS     0xE0

#define ZCL_CMD_MATCH(p, mfg, dir, type)  \
   ((*(const uint8_t FAR *)(p) &                               \
   (ZCL_FRAME_MFG_SPECIFIC | ZCL_FRAME_DIRECTION | ZCL_FRAME_TYPE_MASK)) ==   \
   (ZCL_FRAME_ ## mfg | ZCL_FRAME_ ## dir | ZCL_FRAME_TYPE_ ## type))

#define ZCL_CMD_IS_PROFILE(p) \
   (ZCL_FRAME_TYPE_PROFILE == (*(const uint8_t FAR *)(p) & ZCL_FRAME_TYPE_MASK))

#define ZCL_CMD_IS_MFG_CLUSTER(p)   \
   ((ZCL_FRAME_TYPE_CLUSTER | ZCL_FRAME_MFG_SPECIFIC) ==    \
   ((const uint8_t FAR *)(p) & (ZCL_FRAME_TYPE_MASK | ZCL_FRAME_MFG_SPECIFIC)))

#define ZCL_CMD_IS_CLUSTER(p)    (ZCL_FRAME_TYPE_CLUSTER ==    \
   (*(const uint8_t FAR *)(p) & (ZCL_FRAME_TYPE_MASK | ZCL_FRAME_MFG_SPECIFIC)))

#define ZCL_STATUS_SUCCESS                                      0x00
#define ZCL_STATUS_FAILURE                                      0x01
#define ZCL_STATUS_NOT_AUTHORIZED                               0x7e
#define ZCL_STATUS_RESERVED_FIELD_NOT_ZERO                      0x7f
#define ZCL_STATUS_MALFORMED_COMMAND                            0x80
#define ZCL_STATUS_UNSUP_CLUSTER_COMMAND                        0x81
#define ZCL_STATUS_UNSUP_GENERAL_COMMAND                        0x82
#define ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND                  0x83
#define ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND                  0x84
#define ZCL_STATUS_INVALID_FIELD                                0x85
#define ZCL_STATUS_UNSUPPORTED_ATTRIBUTE                        0x86
#define ZCL_STATUS_INVALID_VALUE                                0x87
#define ZCL_STATUS_READ_ONLY                                    0x88
#define ZCL_STATUS_INSUFFICIENT_SPACE                           0x89
#define ZCL_STATUS_DUPLICATE_EXISTS                             0x8a
#define ZCL_STATUS_NOT_FOUND                                    0x8b
#define ZCL_STATUS_UNREPORTABLE_ATTRIBUTE                       0x8c
#define ZCL_STATUS_INVALID_DATA_TYPE                            0x8d
#define ZCL_STATUS_INVALID_SELECTOR                             0x8e
#define ZCL_STATUS_WRITE_ONLY                                   0x8f
#define ZCL_STATUS_INCONSISTENT_STARTUP_STATE                   0x90
#define ZCL_STATUS_DEFINED_OUT_OF_BAND                          0x91
#define ZCL_STATUS_ABORT                                        0x95
#define ZCL_STATUS_INVALID_IMAGE                                0x96
#define ZCL_STATUS_WAIT_FOR_DATA                                0x97
#define ZCL_STATUS_NO_IMAGE_AVAILABLE                           0x98
#define ZCL_STATUS_REQUIRE_MORE_IMAGE                           0x99
#define ZCL_STATUS_HARDWARE_FAILURE                             0xc0
#define ZCL_STATUS_SOFTWARE_FAILURE                             0xc1
#define ZCL_STATUS_CALIBRATION_ERROR                            0xc2

const char *zcl_status_text( uint_fast8_t status);

#define ZCL_CMD_READ_ATTRIB               0x00

#define ZCL_CMD_READ_ATTRIB_RESP          0x01

#define ZCL_CMD_WRITE_ATTRIB              0x02

#define ZCL_CMD_WRITE_ATTRIB_UNDIV        0x03

#define ZCL_CMD_WRITE_ATTRIB_RESP         0x04

#define ZCL_CMD_WRITE_ATTRIB_NORESP       0x05

#define ZCL_CMD_CONFIGURE_REPORT          0x06

#define ZCL_CMD_CONFIGURE_REPORT_RESP     0x07

#define ZCL_CMD_READ_REPORT_CFG           0x08

#define ZCL_CMD_READ_REPORT_CFG_RESP      0x09

#define ZCL_CMD_REPORT_ATTRIB             0x0a

#define ZCL_CMD_DEFAULT_RESP              0x0b

#define ZCL_CMD_DISCOVER_ATTRIB           0x0c

#define ZCL_CMD_DISCOVER_ATTRIB_RESP      0x0d

#define ZCL_CMD_READ_STRUCT_ATTRIB        0x0e

#define ZCL_CMD_WRITE_STRUCT_ATTRIB       0x0f

#define ZCL_CMD_WRITE_STRUCT_ATTRIB_RESP  0x10


typedef XBEE_PACKED(zcl_attrib_t, {
   uint16_t id_le;
   uint8_t  type;       
   uint8_t  value[1];   
}) zcl_attrib_t;

typedef XBEE_PACKED(zcl_rec_read_attrib_resp_t, {
   uint16_t id_le;
   uint8_t  status;
   uint8_t  type;       
   uint8_t  value[1];   
}) zcl_rec_read_attrib_resp_t;

typedef XBEE_PACKED(zcl_rec_read_attrib_error_resp_t, {
   uint16_t id_le;
   uint8_t  status;
}) zcl_rec_read_attrib_error_resp_t;

typedef XBEE_PACKED(zcl_rec_read_attrib_array_resp_t, {
   uint16_t id_le;
   uint8_t  status;
   uint8_t  type;       
   uint8_t  element_type;
   uint16_t count_le;
   uint8_t  value[1];   
}) zcl_rec_read_attrib_array_resp_t;

typedef XBEE_PACKED(zcl_rec_read_attrib_struct_resp_t, {
   uint16_t id_le;
   uint8_t  status;
   uint8_t  type;          
   uint16_t count_le;      
   uint8_t  elements[1];   
}) zcl_rec_read_attrib_struct_resp_t;

typedef XBEE_PACKED(zcl_rec_write_attrib_status_t, {
   uint8_t  status;
   uint16_t id_le;
}) zcl_rec_write_attrib_status_t;


// Configure Reporting Command (ZCL_CMD_CONFIGURE_REPORT)
// payload is 1 to n variable-length Attribute Reporting Configuration records
// There are two different packet types, based on whether direction is SEND
// or RECEIVE.
#define ZCL_DIRECTION_SEND    0x00     // attributes sent (or reported)
#define ZCL_DIRECTION_RECEIVE 0x01     // attributes received
typedef XBEE_PACKED(zcl_rec_report_send_t, {
   uint8_t  direction;     // 0x00 (ZCL_DIRECTION_SEND)
   uint16_t attrib_id_le;
   uint8_t  attrib_type;
   uint16_t min_interval_le;        // minimum reporting interval (in seconds)
   uint16_t max_interval_le;        // maximum reporting interval (in seconds)
            // Note:  If max_interval is 0xffff, device shall not issue reports
            // for the specified attribute.
}) zcl_rec_report_send_t;

typedef XBEE_PACKED(zcl_rec_report_receive_t, {
   uint8_t  direction;     // 0x01 (ZCL_DIRECTION_RECEIVE)
   uint16_t attrib_id_le;
   uint16_t timeout_period_le;      // number of seconds, or 0 for no timeout
}) zcl_rec_report_receive_t;

typedef union zcl_rec_report_t {
   XBEE_PACKED(, {
      uint8_t  direction;     // ZCL_DIRECTION_SEND or ZCL_DIRECTION_RECEIVE
      uint16_t attrib_id_le;
   }) common;
   zcl_rec_report_send_t      send;
   zcl_rec_report_receive_t   receive;
} zcl_rec_reporting_config_t;

// Configure Reporting Response Command (ZCL_CMD_WRITE_REPORT_CFG_RESP)
// payload is two bytes (ZCL_STATUS_SUCCESS followed by a direction) if all
// writes were successful or 1 to n 4-byte Attribute Status Records for each
// write that failed
// Note: this structure is identical to the one for Read Reporting Configuration
// Command (ZCL_CMD_READ_REPORT_CFG), with the addition of a 1-byte status.
typedef XBEE_PACKED(zcl_rec_reporting_status_t, {
   uint8_t  status;
   uint8_t  direction;     // ZCL_DIRECTION_SEND or ZCL_DIRECTION_RECEIVE
   uint16_t attrib_id_le;
}) zcl_rec_reporting_status_t;

// Read Reporting Configuration Command (ZCL_CMD_READ_REPORT_CFG)
// payload is 1 to n 3-byte Attribute Records
typedef XBEE_PACKED(zcl_rec_read_report_cfg_t, {
   uint8_t  direction;     // ZCL_DIRECTION_SEND or ZCL_DIRECTION_RECEIVE
   uint16_t attrib_id_le;
}) zcl_rec_read_report_cfg_t;

// Read Reporting Configuration Response Command (ZCL_CMD_READ_REPORT_CFG_RESP)
// payload is 1 to n variable-length records as follows:
//  - for non-success status, the 4-byte record format used by Configure
//    Reporting Response Command (status, direction, attrib_id).
//  - for success status, a status byte followed by a zcl_rec_report_send_t
//    record (if direction is ZCL_DIRECTION_SEND) or a zcl_rec_report_receive_t
//    record (if direction is ZCL_DIRECTION_RECEIVE)
/* combined typedef?
typedef XBEE_PACKED(zcl_rec_report_resp_t, {
   uint8_t  status;
   union {
      struct {
         uint8_t  direction;
         uint16_t attrib_id_le;
      } error;          // .status != ZCL_STATUS_SUCCESS
      zcl_rec_report_send_t      send_cfg;
      zcl_rec_report_receive_t   receive_cfg;
   } u;
}) zcl_rec_report_resp_t;
*/

typedef XBEE_PACKED(zcl_rec_report_error_resp_t, {
   uint8_t  status;        // Set to anything except ZCL_STATUS_SUCCESS (0x00)
   uint8_t  direction;
   uint16_t attrib_id_le;
}) zcl_rec_report_error_resp_t;
typedef XBEE_PACKED(zcl_rec_report_send_resp_t, {
   uint8_t                    status;     // Set to ZCL_STATUS_SUCCESS (0x00)
   zcl_rec_report_send_t      report_cfg;
      // report_cfg.direction set to 0x00 (ZCL_DIRECTION_SEND)
}) zcl_rec_report_send_resp_t;
typedef XBEE_PACKED(zcl_rec_report_receive_resp_t, {
   uint8_t                    status;     // Set to ZCL_STATUS_SUCCESS (0x00)
   zcl_rec_report_receive_t   report_cfg;
      // report_cfg.direction set to 0x01 (ZCL_DIRECTION_RECEIVE)
}) zcl_rec_report_receive_resp_t;


/*
   Logic for handling a Read Reporting Configuration Response Command frame:

   char *buffer;
   zcl_rec_report_error_resp_t      *resp_error;
   zcl_rec_report_send_resp_t       *resp_send;
   zcl_rec_report_receive_resp_t    *resp_receive;

   resp_error = (zcl_rec_report_error_resp_t *) buffer;
   if (resp_error->status != ZCL_STATUS_SUCCESS) {
      // process error in resp_error
      buffer += sizeof (*resp_error);
   } else if (resp_error->direction == ZCL_DIRECTION_SEND) {
      resp_send = (zcl_rec_report_send_resp_t *) buffer;
      // process record in resp_send
      buffer += sizeof (*resp_send);
   } else if (resp_error->direction == ZCL_DIRECTION_RECEIVE) {
      resp_send = (zcl_rec_report_receive_resp_t *) buffer;
      // process record in resp_receive
      buffer += sizeof (*resp_receive);
   } else {
      // bad packet
   }
*/

// Report Attributes Command (ZCL_CMD_REPORT_ATTRIB)
// payload is 1 to n variable-length Attribute Report Records

// use zcl_attrib_t

typedef XBEE_PACKED(zcl_default_response_t, {
   uint8_t  command;
   uint8_t  status;
}) zcl_default_response_t;

typedef XBEE_PACKED(zcl_discover_attrib_t, {
   uint16_t start_attrib_id_le;
   uint8_t  max_return_count;
}) zcl_discover_attrib_t;

typedef XBEE_PACKED(zcl_rec_attrib_report_t, {
   uint16_t id_le;
   uint8_t  type;
}) zcl_rec_attrib_report_t;
typedef XBEE_PACKED(zcl_discover_attrib_resp_t, {
   uint8_t                    discovery_complete;
   zcl_rec_attrib_report_t    attrib[1];
}) zcl_discover_attrib_resp_t;

// Read Attributes Structured Command (ZCL_CMD_READ_STRUCT_ATTRIB)
// payload is 1 to n variable-byte Attribute ID and Selector fields
typedef XBEE_PACKED(zcl_selector_t, {
   uint8_t  indicator;
      #define ZCL_INDICATOR_INDICES_MASK     0x0F

      #define ZCL_INDICATOR_ACTION_MASK      0xF0
      #define ZCL_INDICATOR_REPLACE          0x00
      #define ZCL_INDICATOR_ADD_ELEMENT      0x10
      #define ZCL_INDICATOR_REMOVE_ELEMENT   0x20
      // indicator actions 0x30 to 0xF0 are reserved
   uint16_t index_le[15];
}) zcl_selector_t;
typedef XBEE_PACKED(zcl_read_struct_attrib_t, {
   uint16_t       attrib_id_le;
   zcl_selector_t selector;
}) zcl_read_struct_attrib_t;


// Write Attributes Structured Command (ZCL_CMD_WRITE_STRUCT_ATTRIB)
// payload is 1 to n variable-length Write Structured Attribute Record fields.
typedef XBEE_PACKED(zcl_rec_write_struct_attrib_t, {
   uint16_t       id_le;
   zcl_selector_t selector;
   uint8_t        type;
   uint8_t        value[1];      // variable length, depending on type
}) zcl_rec_write_struct_attrib_t;

// Write Attributes Structured Response Cmd (ZCL_CMD_WRITE_STRUCT_ATTRIB_RESP)
// payload is 1 to n variable-length Write Structure Attribute Status Record
// fields.
typedef XBEE_PACKED(zcl_rec_write_struct_attrib_resp_t, {
   uint8_t        status;
   uint16_t       id;
   zcl_selector_t selector;
}) zcl_rec_write_struct_attrib_resp_t;




/*
   Some thoughts on these structures...

   One problem with the attrib status records is that for unknown data types,
   you don't know how long the record is.  Parsing a ZCL_CMD_READ_ATTRIB_RESP
   will be difficult if an attribute has an unknown type (on the plus side,
   a device should only be requesting attributes with types it already
   understands).

*/

typedef union zcl_attribute_minmax_t {
   int32_t        _signed;
   uint32_t       _unsigned;
   float          _float;
} zcl_attribute_minmax_t;

struct zcl_attribute_base_t;
struct zcl_attribute_full_t;
typedef uint_fast8_t (*zcl_attribute_update_fn)(
   const struct zcl_attribute_full_t FAR *entry);

typedef struct zcl_attribute_write_rec_t
{
   const uint8_t FAR *buffer;

   int16_t buflen;

   uint8_t  flags;
      #define ZCL_ATTR_WRITE_FLAG_NONE       0x00
      #define ZCL_ATTR_WRITE_FLAG_ASSIGN     0x01

      #define ZCL_ATTR_WRITE_FLAG_WRITE_REQ  0x00
      #define ZCL_ATTR_WRITE_FLAG_READ_RESP  0x02

   uint8_t  status;
} zcl_attribute_write_rec_t;

typedef int (*zcl_attribute_write_fn)(
   const struct zcl_attribute_full_t   FAR *entry,
   zcl_attribute_write_rec_t              *rec);

typedef struct zcl_attribute_base_t
{
   uint16_t                   id;
   uint8_t                    flags;
      #define ZCL_ATTRIB_FLAG_NONE        0x00  
      #define ZCL_ATTRIB_FLAG_WRITEONLY   0x01  
      #define ZCL_ATTRIB_FLAG_READONLY    0x02  
      #define ZCL_ATTRIB_FLAG_HAS_MIN     0x04  
      #define ZCL_ATTRIB_FLAG_HAS_MAX     0x08  
      #define ZCL_ATTRIB_FLAG_REPORTABLE  0x10  

      // flags available for future use
      #define ZCL_ATTRIB_FLAG_UNUSED1     0x20  

      #define ZCL_ATTRIB_FLAG_RAW         0x40

      #define ZCL_ATTRIB_FLAG_FULL        0x80

   uint8_t                    type;

   const void           FAR   *value;

} zcl_attribute_base_t;

typedef struct zcl_attribute_full_t
{
   zcl_attribute_base_t    base;

   zcl_attribute_minmax_t     min;

   zcl_attribute_minmax_t     max;

   zcl_attribute_update_fn    read;

   zcl_attribute_write_fn     write;
} zcl_attribute_full_t;

// DEVNOTE: This isn't an extension of zcl_attribute_base_t (like
// zcl_attribute_full_t) because its size can change and therefore can't be
// stored in flash.  It's also necessary to be separate to support arrays of
// arrays.
typedef struct zcl_array_t
{
   uint16_t             max_count;     
   uint16_t             current_count; 
   uint16_t             element_size;  
   uint8_t              type;          
   const void     FAR   *value;
} zcl_array_t;

typedef struct zcl_struct_element_t
{
   uint8_t              zcl_type;      
   uint16_t             offset;        
} zcl_struct_element_t;

typedef struct zcl_struct_t
{
   uint16_t                            element_count;
   const void                    FAR   *base_address;
   const zcl_struct_element_t    FAR   *element;
} zcl_struct_t;

// DEVNOTE: consider a flag in zcl_struct_element_t and zcl_array_t to
// indicate that underlying value should have ZCL_ATTRIB_FLAG_RAW, or to
// provide a maximum length if the element is a writeable string.

#define ZCL_ATTRIBUTE_END_OF_LIST      0xFFFF

#define ZCL_MFG_NONE                   0x0000
typedef struct zcl_attribute_tree_t
{
   uint16_t                      manufacturer_id;

   const zcl_attribute_base_t FAR *server;

   const zcl_attribute_base_t FAR *client;
} zcl_attribute_tree_t;

extern const zcl_attribute_tree_t FAR zcl_attributes_none[1];

typedef struct zcl_command_t {
   const wpan_envelope_t      FAR   *envelope;
   uint8_t                          frame_control;
   uint16_t                         mfg_code;
   uint8_t                          sequence;
   uint8_t                          command;
   const zcl_attribute_base_t FAR   *attributes;
   const void                 FAR   *zcl_payload;
   int16_t                          length;
} zcl_command_t;

int zcl_command_build( zcl_command_t *cmd,
   const wpan_envelope_t FAR *envelope, zcl_attribute_tree_t FAR *tree);

void zcl_command_dump( const zcl_command_t *cmd);
void zcl_envelope_payload_dump( const wpan_envelope_t *envelope);

int zcl_general_command( const wpan_envelope_t FAR *envelope,
   void FAR *context);

int zcl_invalid_cluster( const wpan_envelope_t FAR *envelope,
   wpan_ep_state_t FAR *ep_state);
int zcl_invalid_command( const wpan_envelope_t FAR *envelope);

int zcl_build_header( zcl_header_response_t *rsp, zcl_command_t *cmd);
int zcl_parse_attribute_record( const zcl_attribute_base_t FAR *entry,
   zcl_attribute_write_rec_t *rec);
int zcl_default_response( zcl_command_t *cmd, uint8_t status);

int zcl_check_minmax( const zcl_attribute_base_t FAR *entry,
   const uint8_t FAR *buffer_le);

uint32_t zcl_convert_24bit( const void FAR *value_le, bool_t extend_sign);

int zcl_decode_attribute( const zcl_attribute_base_t FAR *entry,
   zcl_attribute_write_rec_t *rec);
int zcl_encode_attribute_value( uint8_t FAR *buffer, int16_t bufsize,
   const zcl_attribute_base_t FAR *entry);

const zcl_attribute_base_t FAR *zcl_attribute_get_next(
   const zcl_attribute_base_t FAR *entry);
const zcl_attribute_base_t FAR *zcl_find_attribute(
   const zcl_attribute_base_t FAR *entry, uint16_t search_id);
int zcl_send_response( zcl_command_t *cmd, const void FAR *payload,
   uint16_t length);

XBEE_END_DECLS

// If compiling in Dynamic C, automatically #use the appropriate C file.
#ifdef __DC__
   #use "zigbee_zcl.c"
#endif

#endif   // __ZIGBEE_ZCL_H