zigpc_common_zigbee.h

Go to the documentation of this file.

/******************************************************************************
 * # License
 * <b>Copyright 2020 Silicon Laboratories Inc. www.silabs.com</b>
 ******************************************************************************
 * The licensor of this software is Silicon Laboratories Inc. Your use of this
 * software is governed by the terms of Silicon Labs Master Software License
 * Agreement (MSLA) available at
 * www.silabs.com/about-us/legal/master-software-license-agreement. This
 * software is distributed to you in Source Code format and is governed by the
 * sections of the MSLA applicable to Source Code.
 *
 *****************************************************************************/
 
#ifndef ZIGPC_COMMON_ZIGBEE_H
#define ZIGPC_COMMON_ZIGBEE_H
 
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "sl_status.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define ZIGBEE_EUI64_SIZE 8
 
#define ZIGBEE_NULL_EUI64                          \
  {                                                \
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF \
  }
 
#define ZIGBEE_NULL_EUI64_UINT 0xFFFFFFFFFFFFFFFF
 
#define ZIGBEE_EUI64_HEX_STR_LENGTH ((ZIGBEE_EUI64_SIZE * 2) + 1)
 
#define ZIGBEE_EXTENDED_PAN_ID_SIZE 8
 
#define ZIGBEE_INSTALL_CODE_LENGTH (16 + 2)
 
#define ZIGBEE_MAX_ENDPOINT_COUNT 255
 
#define ZIGBEE_INVALID_APP_ENDPOINT_ID 0
#define ZIGBEE_DEFAULT_APP_ENDPOINT_ID 1
 
#define ZCL_DEFAULT_STR_LENGTH 256
 
#define ZCL_DEFAULT_ARR_LENGTH 16
 
#define ZCL_GROUP_NAME_LENGTH 16 
 
#define ZCL_MIN_CLUSTER_ID 0x0000
#define ZCL_MAX_CLUSTER_ID 0x7fff
#define ZCL_MIN_MFCTR_ID   0xfc00
#define ZCL_MAX_MFCTR_ID   0xffff
 
#define ZCL_MIN_COMMAND_ID 0x00
#define ZCL_MAX_COMMAND_ID 0x7f
 
#define ZCL_MIN_STD_ATTR_ID  0x0000
#define ZCL_MAX_STD_ATTR_ID  0x4fff
#define ZCL_MIN_GLOB_ATTR_ID 0xf000
#define ZCL_MAX_GLOB_ATTR_ID 0xfffe
 
#define ZCL_INVALID_CLUSTER_ID (ZCL_MAX_CLUSTER_ID + 1)
 
#define ZCL_INVALID_ATTR_ID    (ZCL_MAX_STD_ATTR_ID + 1)
#define ZCL_INVALID_COMMAND_ID 0x80
 
#define ZCL_MIN_CLUSTER_ID 0x0000
#define ZCL_MAX_CLUSTER_ID 0x7fff
#define ZCL_MIN_MFCTR_ID   0xfc00
#define ZCL_MAX_MFCTR_ID   0xffff
#define ZCL_MIN_COMMAND_ID 0x00
#define ZCL_MAX_COMMAND_ID 0x7f
 
#define ZCL_FRAME_BUFFER_SIZE_MAX 255
 
#define ZCL_FRAME_CONTROL_FRAME_TYPE_GLOBAL_COMMAND ((uint8_t)(0x0 << 0))
 
#define ZCL_FRAME_CONTROL_FRAME_TYPE_CLUSTER ((uint8_t)(0x1 << 0))
 
#define ZCL_FRAME_CONTROL_DIRECTION_CLIENT_TO_SERVER ((uint8_t)(0x0 << 3))
 
#define ZCL_GLOBAL_COMMAND_ID_READ_ATTRIBUTES  (0x00)
#define ZCL_GLOBAL_COMMAND_ID_WRITE_ATTRIBUTES (0x02)
 
#define ZCL_ATTRIBUTE_RESPONSE_RECORDS_MAX 20
 
typedef uint8_t zigbee_eui64_t[ZIGBEE_EUI64_SIZE];
 
typedef uint64_t zigbee_eui64_uint_t;
 
typedef uint8_t zigbee_install_code_t[ZIGBEE_INSTALL_CODE_LENGTH];
 
typedef uint16_t zigbee_panid_t;
 
typedef uint8_t zigbee_ext_panid_t[ZIGBEE_EXTENDED_PAN_ID_SIZE];
 
typedef uint8_t zigbee_radio_channel_t;
 
typedef uint16_t zigbee_group_id_t;
 
static const zigbee_group_id_t ZIGBEE_NULL_GROUP_ID = 0;
 
/*
 * @brief Zigbee Network Multicast identifier
 *
 */
typedef uint16_t zigbee_multicast_id_t;
 
typedef uint8_t zigbee_endpoint_id_t;
 
typedef uint16_t zcl_cluster_id_t;
 
typedef uint16_t zcl_attribute_id_t;
 
static const bool ATTR_DIRECTION_REPORTED = true;
static const bool ATTR_DIRECTION_DESIRED  = !ATTR_DIRECTION_REPORTED;
 
typedef uint8_t zcl_command_id_t;
 
typedef enum {
  ZCL_CLUSTER_GENERATED_COMMAND = 1, 
  ZCL_CLUSTER_RECEIVED_COMMAND  = 2, 
} zcl_command_type_t;
 
typedef uint8_t zcl_command_field_t;
 
enum zcl_status_type {
  ZCL_OP_STATUS_SUCCESS = 0,
};
 
enum zcl_frame_data_type {
  ZCL_DATA_TYPE_UNKNOWN = 0,
  ZCL_DATA_TYPE_BOOL    = 0x10,
  ZCL_DATA_TYPE_MAP8    = 0x18,
  ZCL_DATA_TYPE_UINT8   = 0x20,
  ZCL_DATA_TYPE_UINT16  = 0x21,
  ZCL_DATA_TYPE_UINT32  = 0x23,
  ZCL_DATA_TYPE_INT8    = 0x28,
  ZCL_DATA_TYPE_INT16   = 0x29,
  ZCL_DATA_TYPE_INT32   = 0x2A,
  ZCL_DATA_TYPE_ENUM8   = 0x30,
  ZCL_DATA_TYPE_ENUM16  = 0x31,
  ZCL_DATA_TYPE_MAX_VAL,
};
 
typedef struct {
  size_t size;
  size_t offset_sequence_id;
  uint8_t buffer[ZCL_FRAME_BUFFER_SIZE_MAX];
} zcl_frame_t;
 
typedef struct zcl_command {
  uint16_t cluster_id;
  zcl_command_id_t command_id;
  size_t field_count;
} zcl_command_t;
 
static const zcl_command_t null_command = {
  .cluster_id = ZCL_INVALID_CLUSTER_ID, .command_id = ZCL_INVALID_COMMAND_ID};
 
typedef enum e_zcl_cluster_side {
  ZCL_CLUSTER_SERVER_SIDE = 1,
  ZCL_CLUSTER_CLIENT_SIDE = 2
} zcl_cluster_side_t;
 
enum e_zcl_attribute_type {
  ZCL_ATTR_TYPE_INVALID = -1,
  ZCL_ATTR_TYPE_BOOL    = 0x10,
  ZCL_ATTR_TYPE_MAP8    = 0x18,
  ZCL_ATTR_TYPE_UINT8   = 0x20,
  ZCL_ATTR_TYPE_UINT16  = 0x21,
  ZCL_ATTR_TYPE_INT16   = 0x29,
  ZCL_ATTR_TYPE_ENUM8   = 0x30,
  ZCL_ATTR_TYPE_FLOAT   = 0x38
};
 
typedef struct zcl_attribute {
  zcl_cluster_id_t cluster_id;
  zcl_attribute_id_t attribute_id;
  enum e_zcl_attribute_type type;
  bool is_reportable; 
  char attribute_name[ZCL_DEFAULT_STR_LENGTH];
  char desired_payload[ZCL_DEFAULT_STR_LENGTH];
  char reported_payload[ZCL_DEFAULT_STR_LENGTH];
} zcl_attribute_t;
 
typedef struct {
  zcl_cluster_id_t cluster_id;
  enum e_zcl_cluster_side role;
} zcl_cluster_type_t;
 
typedef struct {
  zigbee_endpoint_id_t endpoint_id;
  zcl_cluster_type_t cluster_list[ZCL_DEFAULT_ARR_LENGTH];
  unsigned int cluster_count;
  zcl_cluster_type_t client_cluster_list[ZCL_DEFAULT_ARR_LENGTH];
  unsigned int client_cluster_count;
} zigbee_endpoint_t;
 
typedef struct zcl_profile {
  char cluster_name[ZCL_DEFAULT_STR_LENGTH];
  zcl_cluster_id_t cluster_id;
 
  const zcl_attribute_t *attribute_list;
  unsigned int num_attributes;
 
} zcl_profile_t;
 
typedef struct 
{
    zigbee_eui64_uint_t source_address;
    zigbee_endpoint_id_t source_endpoint;
    zcl_cluster_id_t source_cluster;
    zigbee_eui64_uint_t dest_address;
    zigbee_endpoint_id_t dest_endpoint;
} zigbee_binding_t;
 
static const zigbee_binding_t NULL_BINDING = {0};
 
typedef enum zigbee_node_network_status {
  ZIGBEE_NODE_STATUS_INVALID = 0,
 
  ZIGBEE_NODE_STATUS_NODEID_ASSIGNED,
 
  ZIGBEE_NODE_STATUS_INCLUDED,
 
  ZIGBEE_NODE_STATUS_INTERVIEW_FAIL,
 
  ZIGBEE_NODE_STATUS_INTERVIEWING,
 
  ZIGBEE_NODE_STATUS_OFFLINE,
 
  ZIGBEE_NODE_STATUS_UNAVAILABLE,
 
  ZIGBEE_NODE_STATUS_MAX_VAL,
} zigbee_node_network_status_t;
 
typedef enum {
    ZDO_SUCCESS = 0x00,
    ZDO_TABLE_FULL = 0x8c,
    ZDO_DEVICE_BIND_TABLE_FULL = 0x8e
} zdo_status_t;
 
typedef struct {
  zigbee_eui64_t eui64;
  zigbee_endpoint_t endpoint_list[ZCL_DEFAULT_ARR_LENGTH];
  unsigned int endpoint_count;
  bool is_active;
  bool is_sleepy;
  enum zigbee_node_network_status network_status;
} zigbee_node_t;
 
zigbee_eui64_uint_t zigbee_eui64_to_uint(const zigbee_eui64_t eui64);
 
sl_status_t zigbee_uint_to_eui64(zigbee_eui64_uint_t src, zigbee_eui64_t dest);
 
void zigbee_eui64_copy_switch_endian(zigbee_eui64_t dst,
                                     const zigbee_eui64_t src);
 
void zigpc_common_switch_endian(uint8_t *source, uint8_t *dest, size_t size);
 
sl_status_t zigbee_eui64_to_str(const zigbee_eui64_t eui64,
                                char *str_buf,
                                const size_t str_length);
 
sl_status_t str_to_zigbee_eui64(const char *str_buf,
                                const size_t str_length,
                                zigbee_eui64_t eui64);
 
sl_status_t zigpc_common_eui64_to_unid(const zigbee_eui64_t eui64,
                                       char *dest_unid,
                                       const size_t dest_unid_length);
 
bool is_valid_zcl_command(const zcl_command_t command);
 
sl_status_t copy_command(const zcl_command_t source, zcl_command_t *dest);
 
bool is_valid_zcl_attribute(const zcl_attribute_t attribute);
 
sl_status_t copy_attribute_list(const zcl_attribute_t *const source,
                                zcl_attribute_t *dest,
                                unsigned int list_size);
 
bool is_valid_zcl_cluster(const zcl_cluster_type_t cluster);
 
sl_status_t copy_cluster_list(const zcl_cluster_type_t *const source,
                              zcl_cluster_type_t *dest,
                              unsigned int list_size);
 
bool is_valid_zigbee_node(const zigbee_node_t node);
 
sl_status_t copy_node(const zigbee_node_t source, zigbee_node_t *dest);
 
bool is_valid_zigbee_endpoint(const zigbee_endpoint_t endpoint);
 
sl_status_t copy_endpoint(const zigbee_endpoint_t source,
                          zigbee_endpoint_t *dest);
 
sl_status_t copy_endpoint_list(const zigbee_endpoint_t *const source,
                               zigbee_endpoint_t *dest,
                               unsigned int list_size);
 
sl_status_t zigpc_common_zcl_frame_init_command(zcl_frame_t *const frame,
                                                zcl_command_id_t command_id,
                                                uint8_t frame_control);
 
sl_status_t zigpc_common_zcl_frame_fill_data(zcl_frame_t *const frame,
                                             enum zcl_frame_data_type type,
                                             const void *data);
 
sl_status_t zigpc_common_zcl_frame_fill_raw(zcl_frame_t *const frame,
                                            const uint8_t *const data,
                                            unsigned int data_size);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZIGPC_COMMON_ZIGBEE_H */