Zigbee Green Power types and defines. See greenpower for documentation.

License#

Copyright 2018 Silicon Laboratories Inc. www.silabs.com

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 SILABS_GP_TYPES_H
#define SILABS_GP_TYPES_H

#include "stack/include/sl_zigbee_types.h"

#define SL_ZIGBEE_GP_BIDIRECTION_INFO_RX_AFTER_TX_MASK        0x01

#define SL_ZIGBEE_GP_BIDIRECTION_INFO_TX_QUEUE_AVAILABLE_MASK 0x02

#define GP_SINK_LIST_ENTRIES 2

#define GP_SIZE_OF_SINK_LIST_ENTRIES_OCTET_STRING (1 + (GP_SINK_LIST_ENTRIES * (sizeof(sl_zigbee_gp_sink_group_t))))

#define GP_PARAMS                                  \
  sl_zigbee_gp_status_t status,                    \
  uint8_t gpdLink,                                 \
  uint8_t sequenceNumber,                          \
  sl_zigbee_gp_address_t * addr,                   \
  sl_zigbee_gp_security_level_t gpdfSecurityLevel, \
  sl_zigbee_gp_key_type_t gpdfSecurityKeyType,     \
  bool autoCommissioning,                          \
  uint8_t bidirectionalInfo,                       \
  uint32_t gpdSecurityFrameCounter,                \
  uint8_t gpdCommandId,                            \
  uint32_t mic,                                    \
  uint8_t proxyTableIndex,                         \
  uint8_t gpdCommandPayloadLength,                 \
  uint8_t * gpdCommandPayload

#define GP_ARGS            \
  status,                  \
  gpdLink,                 \
  sequenceNumber,          \
  addr,                    \
  gpdfSecurityLevel,       \
  gpdfSecurityKeyType,     \
  autoCommissioning,       \
  bidirectionalInfo,       \
  gpdSecurityFrameCounter, \
  gpdCommandId,            \
  mic,                     \
  proxyTableIndex,         \
  gpdCommandPayloadLength, \
  gpdCommandPayload

#define GP_UNUSED_ARGS           \
  (void)status;                  \
  (void)gpdLink;                 \
  (void)sequenceNumber;          \
  (void)addr;                    \
  (void)gpdfSecurityLevel;       \
  (void)gpdfSecurityKeyType;     \
  (void)autoCommissioning;       \
  (void)rxAfterTx;               \
  (void)gpdSecurityFrameCounter; \
  (void)gpdCommandId;            \
  (void)mic;                     \
  (void)proxyTableIndex;         \
  (void)gpdCommandPayloadLength; \
  (void)gpdCommandPayload;

#define GP_PROXY_TABLE_OPTIONS_IN_RANGE (BIT(10))

#define GP_COMMISSIONING_MAX_BYTES (55 - 3)

#define GP_GPD_SRC_ID_FOR_CAHNNEL_CONFIG 0x00000000

#define GP_GPD_SRC_ID_WILDCARD           0xFFFFFFFF

#define GP_GPD_SRC_ID_RESERVED_0 0x00000000

#define GP_GPD_SRC_ID_RESERVED_FFFFFF9 0xFFFFFFF9

#define GP_GPD_SRC_ID_RESERVED_FFFFFFE 0xFFFFFFFE

#define GP_DERIVED_GROUP_ALIAS_NOT_USED 0xffff

#define GP_DMIN_B 32

#define GP_DMIN_U 5

#define GP_DMAX 100

typedef uint32_t sl_zigbee_gp_source_id_t;
typedef uint32_t sl_zigbee_gp_security_frame_counter_t;
typedef uint32_t sl_zigbee_gp_mic_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_gp_status_t
#else
typedef uint8_t sl_zigbee_gp_status_t;
enum
#endif
{
  SL_ZIGBEE_GP_STATUS_OK,
  SL_ZIGBEE_GP_STATUS_MATCH,
  SL_ZIGBEE_GP_STATUS_DROP_FRAME,
  SL_ZIGBEE_GP_STATUS_UNPROCESSED,
  SL_ZIGBEE_GP_STATUS_PASS_UNPROCESSED,
  SL_ZIGBEE_GP_STATUS_TX_THEN_DROP,
  SL_ZIGBEE_GP_STATUS_NO_SECURITY,
  SL_ZIGBEE_GP_STATUS_AUTH_FAILURE,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_gp_security_level_t
#else
typedef uint8_t sl_zigbee_gp_security_level_t;
enum
#endif
{
  SL_ZIGBEE_GP_SECURITY_LEVEL_NONE = 0x00,
  SL_ZIGBEE_GP_SECURITY_LEVEL_RESERVED = 0x01,
  SL_ZIGBEE_GP_SECURITY_LEVEL_FC_MIC = 0x02,
  SL_ZIGBEE_GP_SECURITY_LEVEL_FC_MIC_ENCRYPTED = 0x03,
};
#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_gp_key_type_t
#else
typedef uint8_t sl_zigbee_gp_key_type_t;
enum
#endif
{
  SL_ZIGBEE_GP_SECURITY_KEY_NONE = 0x00,
  SL_ZIGBEE_GP_SECURITY_KEY_NWK = 0x01,
  SL_ZIGBEE_GP_SECURITY_KEY_GPD_GROUP = 0x02,
  SL_ZIGBEE_GP_SECURITY_KEY_NWK_DERIVED = 0x03,
  SL_ZIGBEE_GP_SECURITY_KEY_GPD_OOB = 0x04,
  SL_ZIGBEE_GP_SECURITY_KEY_GPD_DERIVED = 0x07,
};
#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_gp_application_id_t
#else
typedef uint8_t sl_zigbee_gp_application_id_t;
enum
#endif
{
  SL_ZIGBEE_GP_APPLICATION_SOURCE_ID = 0x00,
  SL_ZIGBEE_GP_APPLICATION_IEEE_ADDRESS = 0x02,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_gp_proxy_table_entry_status_t
#else
typedef uint8_t sl_zigbee_gp_proxy_table_entry_status_t;
enum
#endif
{
  SL_ZIGBEE_GP_PROXY_TABLE_ENTRY_STATUS_ACTIVE = 0x01,
  SL_ZIGBEE_GP_PROXY_TABLE_ENTRY_STATUS_UNUSED = 0xFF,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_gp_sink_table_entry_status_t
#else
typedef uint8_t sl_zigbee_gp_sink_table_entry_status_t;
enum
#endif
{
  SL_ZIGBEE_GP_SINK_TABLE_ENTRY_STATUS_ACTIVE = 0x01,
  SL_ZIGBEE_GP_SINK_TABLE_ENTRY_STATUS_UNUSED = 0xFF,
};

typedef struct {
  union {
    sl_802154_long_addr_t gpdIeeeAddress;
    sl_zigbee_gp_source_id_t sourceId;
  } id;
  sl_zigbee_gp_application_id_t applicationId;
  uint8_t endpoint;
} sl_zigbee_gp_address_t;

typedef enum {
  SL_ZIGBEE_GP_SINK_TYPE_FULL_UNICAST,
  SL_ZIGBEE_GP_SINK_TYPE_D_GROUPCAST,
  SL_ZIGBEE_GP_SINK_TYPE_GROUPCAST,
  SL_ZIGBEE_GP_SINK_TYPE_LW_UNICAST,
  SL_ZIGBEE_GP_SINK_TYPE_UNUSED = 0xFF
} sl_zigbee_gp_sink_type_t;

typedef struct {
  sl_802154_long_addr_t sinkEUI;
  sl_802154_short_addr_t sinkNodeId;
} sl_zigbee_gp_sink_address_t;

typedef struct {
  uint16_t groupID;
  uint16_t alias;
} sl_zigbee_gp_sink_group_t;

typedef struct {
  sl_zigbee_gp_sink_type_t type;

  union {
    sl_zigbee_gp_sink_address_t unicast;
    sl_zigbee_gp_sink_group_t groupcast;
    sl_zigbee_gp_sink_group_t groupList;   // Entry for Sink Group List
  } target;
} sl_zigbee_gp_sink_list_entry_t;

typedef struct {
  sl_zigbee_gp_proxy_table_entry_status_t status;
  uint32_t options;
  sl_zigbee_gp_address_t gpd;
  sl_802154_short_addr_t assignedAlias;
  uint8_t securityOptions;
  sl_zigbee_gp_security_frame_counter_t gpdSecurityFrameCounter;
  sl_zigbee_key_data_t gpdKey;
  sl_zigbee_gp_sink_list_entry_t sinkList[GP_SINK_LIST_ENTRIES];
  uint8_t groupcastRadius;
  uint8_t searchCounter;
} sl_zigbee_gp_proxy_table_entry_t;

typedef struct {
  sl_zigbee_gp_sink_table_entry_status_t status;
  uint16_t options;
  sl_zigbee_gp_address_t gpd;
  uint8_t deviceId;
  sl_zigbee_gp_sink_list_entry_t sinkList[GP_SINK_LIST_ENTRIES];
  sl_802154_short_addr_t assignedAlias;
  uint8_t groupcastRadius;
  uint8_t securityOptions;
  sl_zigbee_gp_security_frame_counter_t gpdSecurityFrameCounter;
  sl_zigbee_key_data_t gpdKey;
} sl_zigbee_gp_sink_table_entry_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_c_gp_tx_option_t
#else
typedef uint8_t sl_zigbee_c_gp_tx_option_t;
enum
#endif
{
  SL_ZIGBEE_CGP_TX_OPTION_NONE = 0x00,
  SL_ZIGBEE_CGP_TX_OPTION_USE_CSMA_CA = 0x01,
  SL_ZIGBEE_CGP_TX_OPTION_USE_MAC_ACK = 0x02,
  SL_ZIGBEE_CGP_TX_OPTION_RESERVED = 0xFC,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_c_gp_address_mode_t
#else
typedef uint8_t sl_zigbee_c_gp_address_mode_t;
enum
#endif
{
  SL_ZIGBEE_CGP_ADDRESS_MODE_NONE = 0x00,
  SL_ZIGBEE_CGP_ADDRESS_MODE_RESERVED = 0x01,
  SL_ZIGBEE_CGP_ADDRESS_MODE_SHORT = 0x02,
  SL_ZIGBEE_CGP_ADDRESS_MODE_EXTENDED = 0x03,
};

typedef struct {
  union {
    sl_802154_short_addr_t shortId;
    sl_802154_long_addr_t extendedId;
  } address;
  sl_802154_pan_id_t panId;
  sl_zigbee_c_gp_address_mode_t mode;
} sl_zigbee_c_gp_address_t;
#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_d_gp_tx_option_t
#else
typedef uint8_t sl_zigbee_d_gp_tx_option_t;
enum
#endif
{
  SL_ZIGBEE_DGP_TX_OPTION_NONE = 0x00,
  SL_ZIGBEE_DGP_TX_OPTION_USE_GP_TX_QUEUE = 0x01,
  SL_ZIGBEE_DGP_TX_OPTION_USE_CSMA_CA = 0x02,
  SL_ZIGBEE_DGP_TX_OPTION_USE_MAC_ACK = 0x04,
  SL_ZIGBEE_DGP_TX_OPTION_FRAME_TYPE_DATA = 0x00,
  SL_ZIGBEE_DGP_TX_OPTION_FRAME_TYPE_MAINTENANCE = 0x08,
  SL_ZIGBEE_DGP_TX_OPTION_RESERVED = 0xE0,
};

typedef struct {
  uint8_t foo;
} sl_zigbee_gp_proxy_cluster_attributes_t;

typedef struct {
  bool inUse;
  bool useCca;
  sl_zigbee_gp_address_t addr;
  uint8_t gpdCommandId;
  uint8_t gpepHandle;
  uint16_t queueEntryLifetimeMs;
} sl_zigbee_gp_tx_queue_entry_t;

typedef struct {
  uint8_t deviceId;
  uint8_t applInfoBitmap;
  uint16_t manufacturerId;
  uint16_t modelId;
  uint8_t numberOfGpdCommands;
  uint8_t gpdCommands[GP_COMMISSIONING_MAX_BYTES - 1];
  uint8_t numberOfPairedEndpoints;
  uint8_t pairedEndpoints[GP_COMMISSIONING_MAX_BYTES - 1];
  uint8_t numberOfGpdClientCluster;
  uint8_t numberOfGpdServerCluster;
  uint16_t serverClusters[15];
  uint16_t clientClusters[15];
} sl_zigbee_gp_application_info_t;

typedef struct {
  uint16_t              attributeID;
  uint8_t               attributeDataType;
  uint8_t               remainingAttributRecordLength; // on 4 bits
  uint8_t               reported;
  uint8_t               attrValuePresent;
  uint8_t               attrOffsetWithinReport;
  // TODO change "attrValue" from u32 to a pointer, as the data could be up to a string
  // the field "attributeDataType" tell with format it is, among  more than 55 possibilities)
  // so a add a private field which just tell the length of attrValue to easier
  // process it
  uint32_t              attrValue;
  uint8_t               attrValueSize;
} sl_zigbee_gp_attribute_record_t;
typedef struct {
  // Note: it is "N-1", if there is 2 attr record then nbAttrRecord=1 and not 2 !
  uint8_t               nbAttrRecord;
  uint8_t               clientServer;
  uint8_t               ManIdPresent;
  uint8_t               datapointOptions;
  uint16_t              clusterID;
  uint16_t              manufacturerID;
  sl_zigbee_gp_attribute_record_t attrRecord;
} sl_zigbee_gp_data_point_descriptor_t;

typedef struct {
  uint8_t               repId;
  uint8_t               reportOptions;
  uint16_t              timeoutPeriod;
  uint8_t               totalLength;
  sl_zigbee_gp_data_point_descriptor_t  dataPoint;
} sl_zigbee_gp_report_descriptor_t;
typedef struct {
  uint8_t switchInfoLength;
  uint8_t nbOfContacts;
  uint8_t switchType;
  uint8_t currentContact;
  uint8_t savedContact;
}sl_zigbee_gp_switch_information_t;

typedef struct {
  uint8_t       currentStatus;
  uint8_t       contactBitmask;
} sl_zigbee_gp_generic_switch_data_t;

typedef struct {
  uint8_t       totalLengthOfAddInfoBlock;
  uint8_t       optionSelector;
  union {
    struct {
      uint8_t       reportIdentifier;
      uint8_t       attrOffsetWithinReport;
      uint16_t      clusterID;
      uint16_t      attributeID;
      uint8_t       attributeDataType;
      uint8_t       attributeOptions; //clientServer bit0 manufacturerIdPresent bit1
      uint16_t      manufacturerID;
    } compactAttr;
    struct {
      uint8_t       contactStatus;
      uint8_t       contactBitmask;
    } genericSwitch;
  } optionData;//sl_zigbee_gp_translation_table_additional_info_block_option_record_option_data_field_t;
} sl_zigbee_gp_translation_table_additional_info_block_option_record_field_t;


// -----------------------------------------------------------------------------
// API

sl_status_t sl_zigbee_d_gp_send(bool action,
                                bool useCca,
                                sl_zigbee_gp_address_t *addr,
                                uint8_t gpdCommandId,
                                uint8_t gpdAsduLength,
                                uint8_t const *gpdAsdu,
                                uint8_t gpepHandle,
                                uint16_t gpTxQueueEntryLifetimeMs);

// Tx Queue APIs

sli_zigbee_message_buffer_queue_t * sl_zigbee_gp_get_tx_queue_head(void);

void sl_zigbee_gp_set_max_tx_queue_entry(uint16_t maxEntries);

uint16_t sl_zigbee_get_gp_max_tx_q_list_count(void);

uint16_t sl_zigbee_get_gp_tx_q_list_count(void);

sli_buffer_manager_buffer_t sl_zigbee_gp_get_tx_queue_entry_from_queue(sl_zigbee_gp_tx_queue_entry_t *txQueue,
                                                                       uint8_t *data,
                                                                       uint16_t *dataLength,
                                                                       uint16_t allocatedDataLength);

sl_status_t sl_zigbee_gp_get_tx_queue_entry_from_queue_index(uint8_t index,
                                                             sl_zigbee_gp_tx_queue_entry_t *txQueue,
                                                             uint8_t *payload,
                                                             uint16_t *payload_len);

sli_buffer_manager_buffer_t sl_zigbee_gp_add_gp_tx_queue_entry_with_payload(sl_zigbee_gp_tx_queue_entry_t *txQueue,
                                                                            uint8_t *data,
                                                                            uint16_t dataLength);
bool sl_zigbee_gp_remove_from_tx_queue(sl_zigbee_gp_tx_queue_entry_t *txQueue);

void sl_zigbee_gp_clear_tx_queue(void);

#endif // SILABS_GP_TYPES_H
 // end of name API

Modules#

sl_zigbee_gp_address_t

sl_zigbee_gp_sink_address_t

sl_zigbee_gp_sink_group_t

sl_zigbee_gp_sink_list_entry_t

sl_zigbee_gp_proxy_table_entry_t

sl_zigbee_gp_sink_table_entry_t

sl_zigbee_c_gp_address_t

sl_zigbee_gp_proxy_cluster_attributes_t

sl_zigbee_gp_tx_queue_entry_t

sl_zigbee_gp_application_info_t

sl_zigbee_gp_attribute_record_t

sl_zigbee_gp_data_point_descriptor_t

sl_zigbee_gp_report_descriptor_t

sl_zigbee_gp_switch_information_t

sl_zigbee_gp_generic_switch_data_t

sl_zigbee_gp_translation_table_additional_info_block_option_record_field_t

0x01

0x02

2

(1 + (GP_SINK_LIST_ENTRIES * (sizeof(sl_zigbee_gp_sink_group_t))))

(BIT(10))

(55 - 3)

0x00000000

0xFFFFFFFF

0x00000000

0xFFFFFFF9

0xFFFFFFFE

0xffff

32

5

100