Ember data type definitions.

See Ember Common Data Types for details.

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_EMBER_TYPES_H
#define SILABS_EMBER_TYPES_H

// TODO: temporary hack
#define SIGNED_ENUM

#ifdef PLATFORM_HEADER
 #include PLATFORM_HEADER
#endif // PLATFORM_HEADER

#define MAX_IPC_VEC_ARG_CAPACITY 127

#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include "stack/config/sl_zigbee_configuration_defaults.h"
#endif //DOXYGEN_SHOULD_SKIP_THIS

#include "mac-types.h"


#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_version_type_t
#else
typedef uint8_t sl_zigbee_version_type_t;
enum
#endif
{
  SL_ZIGBEE_VERSION_TYPE_PRE_RELEASE = 0x00,

  //Alpha, should be used rarely
  SL_ZIGBEE_VERSION_TYPE_ALPHA_1     = 0x11,
  SL_ZIGBEE_VERSION_TYPE_ALPHA_2     = 0x12,
  SL_ZIGBEE_VERSION_TYPE_ALPHA_3     = 0x13,
  // Leave space in case we decide to add other types in the future.
  SL_ZIGBEE_VERSION_TYPE_BETA_1      = 0x21,
  SL_ZIGBEE_VERSION_TYPE_BETA_2      = 0x22,
  SL_ZIGBEE_VERSION_TYPE_BETA_3      = 0x23,

  // Anything other than 0xAA is considered pre-release
  // Silicon Labs may define other types in the future (e.g. beta, alpha)
  // Silicon Labs chose an arbitrary number (0xAA) to allow for expansion, but
  // to prevent ambiguity in case 0x00 or 0xFF is accidentally retrieved
  // as the version type.
  SL_ZIGBEE_VERSION_TYPE_GA = 0xAA,
};

typedef struct {
  sl_zigbee_version_type_t typeNum;
  const char *typeString;
} sl_zigbee_release_type_struct_t;

#define SL_ZIGBEE_RELEASE_TYPE_TO_STRING_STRUCT_DATA     \
  { SL_ZIGBEE_VERSION_TYPE_PRE_RELEASE, "Pre-Release" }, \
  { SL_ZIGBEE_VERSION_TYPE_ALPHA_1, "Alpha 1" },         \
  { SL_ZIGBEE_VERSION_TYPE_ALPHA_2, "Alpha 2" },         \
  { SL_ZIGBEE_VERSION_TYPE_ALPHA_3, "Alpha 3" },         \
  { SL_ZIGBEE_VERSION_TYPE_BETA_1, "Beta 1" },           \
  { SL_ZIGBEE_VERSION_TYPE_BETA_2, "Beta 2" },           \
  { SL_ZIGBEE_VERSION_TYPE_BETA_3, "Beta 3" },           \
  { SL_ZIGBEE_VERSION_TYPE_GA, "GA" },                   \
  { 0xFF, NULL },

typedef struct {
  uint16_t build;
  uint8_t major;
  uint8_t minor;
  uint8_t patch;
  uint8_t special;
  sl_zigbee_version_type_t type;
} sl_zigbee_version_t;

extern const sl_zigbee_version_t sl_zigbee_version;

#ifdef ZIGBEE_STACK_ON_HOST

typedef struct {
  const char *date;
  const char *time;
} sl_zigbee_stack_build_date_time_t;

extern const sl_zigbee_stack_build_date_time_t sl_zigbee_stack_build_date_time;

#endif //ZIGBEE_STACK_ON_HOST

#define EUI64_SIZE 8

#define EXTENDED_PAN_ID_SIZE 8

#define SL_ZIGBEE_ENCRYPTION_KEY_SIZE 16

#define SL_ZIGBEE_CERTIFICATE_SIZE 48

#define SL_ZIGBEE_PUBLIC_KEY_SIZE 22

#define SL_ZIGBEE_PRIVATE_KEY_SIZE 21

#define SL_ZIGBEE_SMAC_SIZE 16

#define SL_ZIGBEE_SIGNATURE_SIZE 42

#define SL_ZIGBEE_AES_HASH_BLOCK_SIZE 16

#define SL_ZIGBEE_CERTIFICATE_283K1_SIZE 74

#define SL_ZIGBEE_PUBLIC_KEY_283K1_SIZE 37

#define SL_ZIGBEE_PRIVATE_KEY_283K1_SIZE 36

#define SL_ZIGBEE_SIGNATURE_283K1_SIZE 72

#include "buffer_manager/buffer-management.h"

//typedef uint8_t sl_802154_long_addr_t[EUI64_SIZE];

//typedef uint16_t sli_buffer_manager_buffer_t;
//typedef uint16_t Buffer;

#define NULL_BUFFER 0x0000u

//typedef uint16_t sl_802154_short_addr_t;

typedef uint16_t sl_zigbee_multicast_id_t;

//typedef uint16_t sl_802154_pan_id_t;

typedef uint16_t sl_zigbee_duty_cycle_hecto_pct_t;

#define SL_ZIGBEE_MAX_802_15_4_CHANNEL_NUMBER 26

#define SL_ZIGBEE_MIN_802_15_4_CHANNEL_NUMBER 11

#define SL_ZIGBEE_MIN_SUBGHZ_CHANNEL_NUMBER 0

#define SL_ZIGBEE_ACTIVE_SCAN_DURATION  3

#define SL_ZIGBEE_SUB_GHZ_SCAN_DURATION 5

#define SL_ZIGBEE_NUM_802_15_4_CHANNELS \
  (SL_ZIGBEE_MAX_802_15_4_CHANNEL_NUMBER - SL_ZIGBEE_MIN_802_15_4_CHANNEL_NUMBER + 1)

#define SL_ZIGBEE_ALL_802_15_4_CHANNELS_MASK 0x07FFF800UL

#define SL_ZIGBEE_MAX_CHANNELS_PER_PAGE   27

#define SL_ZIGBEE_ALL_SUBGHZ_CHANNELS_MASK_FOR_PAGES_28_30_31 0x07FFFFFFUL

#define SL_ZIGBEE_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGES_28_30_31   26
#define SL_ZIGBEE_ALL_SUBGHZ_CHANNELS_MASK_FOR_PAGES_29 0x1FF

#define SL_ZIGBEE_MAX_SUBGHZ_CHANNEL_NUMBER_ON_PAGE_29   8

#define SL_ZIGBEE_MIN_SUGBHZ_PAGE_NUMBER  28

#define SL_ZIGBEE_MAX_SUGBHZ_PAGE_NUMBER  31

#define SL_ZIGBEE_ALL_CHANNEL_PAGE_MASK 0xF8000000UL

#define SL_ZIGBEE_PAGE_CHANNEL_MASK_FROM_CHANNEL_MASK(page, mask)                              \
  (((((uint32_t)(page)) << SL_ZIGBEE_MAX_CHANNELS_PER_PAGE) & SL_ZIGBEE_ALL_CHANNEL_PAGE_MASK) \
   | (((uint32_t)(mask)) & ~SL_ZIGBEE_ALL_CHANNEL_PAGE_MASK))

#define SL_ZIGBEE_PAGE_CHANNEL_MASK_FROM_CHANNEL_NUMBER(page, channel) \
  SL_ZIGBEE_PAGE_CHANNEL_MASK_FROM_CHANNEL_MASK(page, BIT32(channel))

#define SL_ZIGBEE_ZIGBEE_COORDINATOR_ADDRESS 0x0000u

#define SL_ZIGBEE_NULL_NODE_ID 0xFFFFu

#define SL_ZIGBEE_NO_CHANNEL_PAGE_IN_USE           0
#define SL_ZIGBEE_NULL_EUI64 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }

#define SL_ZIGBEE_NULL_BINDING 0xFFu

#define SL_ZIGBEE_TABLE_ENTRY_UNUSED_NODE_ID  0xFFFFu

#define SL_ZIGBEE_MULTICAST_NODE_ID           0xFFFEu

#define SL_ZIGBEE_UNKNOWN_NODE_ID             0xFFFDu

#define SL_ZIGBEE_DISCOVERY_ACTIVE_NODE_ID    0xFFFCu

#define SL_ZIGBEE_NULL_ADDRESS_TABLE_INDEX 0xFFu

#define SL_ZIGBEE_ZDO_ENDPOINT 0u

#define SL_ZIGBEE_BROADCAST_ENDPOINT 0xFFu

#define SL_ZIGBEE_GP_ENDPOINT 0xF2u

#define SL_ZIGBEE_ZDO_PROFILE_ID  0x0000u

#define SL_ZIGBEE_WILDCARD_PROFILE_ID  0xFFFFu

#define SL_ZIGBEE_MAXIMUM_STANDARD_PROFILE_ID  0x7FFFu

#define SL_ZIGBEE_BROADCAST_TABLE_TIMEOUT_QS (20 * 4)

#define SL_ZIGBEE_MANUFACTURER_ID 0x1002u

#define SL_ZIGBEE_NULL_NETWORK_INDEX 0xFFu

#define SL_ZIGBEE_DC_LIMIT_USE_DEFAULT 0

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_leave_network_option_t
#else
typedef uint8_t sl_zigbee_leave_network_option_t;
enum
#endif
{
  SL_ZIGBEE_LEAVE_NWK_WITH_NO_OPTION      = 0x00,
  SL_ZIGBEE_LEAVE_NWK_WITH_OPTION_REJOIN  = 0x20,
  SL_ZIGBEE_LEAVE_NWK_IS_REQUESTED        = 0x40,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_stack_profile_t
#else
typedef uint8_t sl_zigbee_stack_profile_t;
enum
#endif
{
  SL_ZIGBEE_STACK_PROFILE_NONE       = 0x00,
  SL_ZIGBEE_STACK_PROFILE_ZIGBEE_PRO = 0x02,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_security_level_t
#else
typedef uint8_t sl_zigbee_security_level_t;
enum
#endif
{
  SL_ZIGBEE_SECURITY_LEVEL_NONE = 0x00,
  SL_ZIGBEE_SECURITY_LEVEL_Z3   = 0x05,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_leave_request_flags_t
#else
typedef uint8_t sl_zigbee_leave_request_flags_t;
enum
#endif
{
  SL_ZIGBEE_ZIGBEE_LEAVE_AND_REJOIN     = 0x80,

  // Note: removeChildren is treated to be deprecated and should not be used!
  // CCB 2047
  // - CCB makes the first step to deprecate the 'leave and remove children' functionality.
  // - We were proactive here and deprecated it right away.
  // SL_ZIGBEE_ZIGBEE_LEAVE_AND_REMOVE_CHILDREN = 0x40,

  SL_ZIGBEE_ZIGBEE_LEAVE_WITHOUT_REJOIN = 0x00,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_leave_reason_t
#else
typedef uint8_t sl_zigbee_leave_reason_t;
enum
#endif
{
  SL_ZIGBEE_LEAVE_REASON_NONE               = 0,
  SL_ZIGBEE_LEAVE_DUE_TO_NWK_LEAVE_MESSAGE  = 1,
  SL_ZIGBEE_LEAVE_DUE_TO_APS_REMOVE_MESSAGE = 2,
  // Currently, the stack does not process the ZDO leave message since it is optional.
  SL_ZIGBEE_LEAVE_DUE_TO_ZDO_LEAVE_MESSAGE  = 3,
  SL_ZIGBEE_LEAVE_DUE_TO_ZLL_TOUCHLINK      = 4,

  SL_ZIGBEE_LEAVE_DUE_TO_APP_EVENT_1        = 0xFF,
};


#define SL_ZIGBEE_BROADCAST_ADDRESS 0xFFFCu
#define SL_ZIGBEE_RX_ON_WHEN_IDLE_BROADCAST_ADDRESS 0xFFFDu
#define SL_ZIGBEE_SLEEPY_BROADCAST_ADDRESS 0xFFFFu

// From table 3.51 of 053474r14
// When sending many-to-one route requests, the following
// addresses are used
// 0xFFF9 indicates a non-memory-constrained many-to-one route request
// 0xFFF8 indicates a memory-constrained many-to-one route request
#define SL_ZIGBEE_MIN_BROADCAST_ADDRESS 0xFFF8u

#define sl_zigbee_is_zigbee_broadcast_address(address) \
  (SL_ZIGBEE_MIN_BROADCAST_ADDRESS <= ((uint16_t) (address)))

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_node_type_t
#else
typedef uint8_t sl_zigbee_node_type_t;
enum
#endif
{
  SL_ZIGBEE_UNKNOWN_DEVICE = 0,
  SL_ZIGBEE_DEVICE_TYPE_UNCHANGED = SL_ZIGBEE_UNKNOWN_DEVICE,
  SL_ZIGBEE_COORDINATOR = 1,
  SL_ZIGBEE_ROUTER = 2,
  SL_ZIGBEE_END_DEVICE = 3,
  SL_ZIGBEE_SLEEPY_END_DEVICE = 4,
  SL_ZIGBEE_S2S_INITIATOR_DEVICE = 5,
  SL_ZIGBEE_S2S_TARGET_DEVICE = 6,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_end_device_configuration_t
#else
typedef uint8_t sl_zigbee_end_device_configuration_t;
enum
#endif
{
  SL_ZIGBEE_END_DEVICE_CONFIG_NONE                   = 0x00,
  SL_ZIGBEE_END_DEVICE_CONFIG_PERSIST_DATA_ON_PARENT = 0x01,
};

typedef struct {
  uint16_t panId;
  uint8_t channel;
  bool allowingJoin;
  uint8_t extendedPanId[EXTENDED_PAN_ID_SIZE];
  uint8_t stackProfile;
  uint8_t nwkUpdateId;
} sl_zigbee_zigbee_network_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_network_init_bitmask_t
#else
typedef uint16_t sl_zigbee_network_init_bitmask_t;
enum
#endif
{
  SL_ZIGBEE_NETWORK_INIT_NO_OPTIONS           = 0x0000,
  SL_ZIGBEE_NETWORK_INIT_PARENT_INFO_IN_TOKEN = 0x0001,
  SL_ZIGBEE_NETWORK_INIT_END_DEVICE_REJOIN_ON_REBOOT = 0x0002,
};

typedef struct {
  sl_zigbee_network_init_bitmask_t bitmask;
} sl_zigbee_network_init_struct_t;

typedef struct {
  uint16_t nodeId;
  int8_t rssi;
  uint8_t classificationMask;
} sl_zigbee_beacon_survey_t;

typedef struct {
  sl_802154_pan_id_t panId;
  sl_802154_short_addr_t sender;
  uint8_t channel;
  uint8_t lqi;
  int8_t rssi;
  uint8_t depth;
  uint8_t nwkUpdateId;
  int8_t power;           // Only valid if enhanced beacon
  int8_t parentPriority;  // TC connectivity and long uptime from capacity field
  uint8_t supportedKeyNegotiationMethods;
  bool extended_beacon;
  bool enhanced             : 1;  // Enhanced or regular beacon
  bool permitJoin           : 1;
  bool hasCapacity          : 1;
  bool tcConnectivity       : 1;
  bool longUptime           : 1;
  bool preferParent         : 1;
  bool macDataPollKeepalive : 1;
  bool endDeviceKeepalive   : 1;
  uint8_t extendedPanId[EXTENDED_PAN_ID_SIZE];
} sl_zigbee_beacon_data_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_aps_rejoin_mode_t
#else
typedef uint8_t sl_zigbee_aps_rejoin_mode_t;
enum
#endif
{
  NO_REJOIN,
  REJOIN_ANY_LINK_KEY,
  REJOIN_NON_DEFAULT_LINK_KEY
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_aps_option_t
#else
typedef uint16_t sl_zigbee_aps_option_t;
enum
#endif
{
  SL_ZIGBEE_APS_OPTION_NONE                     = 0x0000,

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  SL_ZIGBEE_APS_OPTION_ENCRYPT_WITH_TRANSIENT_KEY = 0x0001,
  SL_ZIGBEE_APS_OPTION_USE_ALIAS_SEQUENCE_NUMBER = 0x0002,
#endif

  SL_ZIGBEE_APS_OPTION_DSA_SIGN                 = 0x0010,
  SL_ZIGBEE_APS_OPTION_ENCRYPTION               = 0x0020,
  SL_ZIGBEE_APS_OPTION_RETRY                    = 0x0040,
  SL_ZIGBEE_APS_OPTION_ENABLE_ROUTE_DISCOVERY   = 0x0100,
  SL_ZIGBEE_APS_OPTION_FORCE_ROUTE_DISCOVERY    = 0x0200,
  SL_ZIGBEE_APS_OPTION_SOURCE_EUI64             = 0x0400,
  SL_ZIGBEE_APS_OPTION_DESTINATION_EUI64        = 0x0800,
  SL_ZIGBEE_APS_OPTION_ENABLE_ADDRESS_DISCOVERY = 0x1000,
  SL_ZIGBEE_APS_OPTION_POLL_RESPONSE            = 0x2000,
  SL_ZIGBEE_APS_OPTION_ZDO_RESPONSE_REQUIRED    = 0x4000,
  SL_ZIGBEE_APS_OPTION_FRAGMENT                 = SIGNED_ENUM 0x8000
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_incoming_message_type_t
#else
typedef uint8_t sl_zigbee_incoming_message_type_t;
enum
#endif
{
  SL_ZIGBEE_INCOMING_UNICAST,
  SL_ZIGBEE_INCOMING_UNICAST_REPLY,
  SL_ZIGBEE_INCOMING_MULTICAST,
  SL_ZIGBEE_INCOMING_MULTICAST_LOOPBACK,
  SL_ZIGBEE_INCOMING_BROADCAST,
  SL_ZIGBEE_INCOMING_BROADCAST_LOOPBACK
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_outgoing_message_type_t
#else
typedef uint8_t sl_zigbee_outgoing_message_type_t;
enum
#endif
{
  SL_ZIGBEE_OUTGOING_DIRECT,
  SL_ZIGBEE_OUTGOING_VIA_ADDRESS_TABLE,
  SL_ZIGBEE_OUTGOING_VIA_BINDING,
  SL_ZIGBEE_OUTGOING_MULTICAST,
  SL_ZIGBEE_OUTGOING_MULTICAST_WITH_ALIAS,
  SL_ZIGBEE_OUTGOING_BROADCAST_WITH_ALIAS,
  SL_ZIGBEE_OUTGOING_BROADCAST
};

// OLD API
#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_zigbee_command_type_t
#else
typedef uint8_t sl_zigbee_zigbee_command_type_t;
enum
#endif
{
  SL_ZIGBEE_ZIGBEE_COMMAND_TYPE_RAW_MAC,
  SL_ZIGBEE_ZIGBEE_COMMAND_TYPE_MAC_COMMAND,
  SL_ZIGBEE_ZIGBEE_COMMAND_TYPE_NWK,
  SL_ZIGBEE_ZIGBEE_COMMAND_TYPE_APS,
  SL_ZIGBEE_ZIGBEE_COMMAND_TYPE_ZDO,
  SL_ZIGBEE_ZIGBEE_COMMAND_TYPE_ZCL,
  SL_ZIGBEE_ZIGBEE_COMMAND_TYPE_BEACON,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_packet_action_t
#else
typedef uint8_t sl_zigbee_packet_action_t;
enum
#endif
{
  SL_ZIGBEE_DROP_PACKET   = 0,
  SL_ZIGBEE_ACCEPT_PACKET = 1,
  SL_ZIGBEE_MANGLE_PACKET,

  SL_ZIGBEE_ACCEPT_PACKET_OVERRIDE_SECURITY,

  SL_ZIGBEE_ACCEPT_PACKET_SKIP_NWK_CRYPTO,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_zigbee_packet_type_t
#else
typedef uint8_t sl_zigbee_zigbee_packet_type_t;
enum
#endif
{
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_RAW_MAC,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_MAC_COMMAND,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_NWK_DATA,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_NWK_COMMAND,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_APS_DATA,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_APS_COMMAND,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_ZDO,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_ZCL,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_BEACON,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_INTERPAN,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_NWK_DATA_PRE_DECRYPTION,
  SL_ZIGBEE_ZIGBEE_PACKET_TYPE_NWK_COMMAND_PRE_DECRYPTION,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_network_status_t
#else
typedef uint8_t sl_zigbee_network_status_t;
enum
#endif
{
  SL_ZIGBEE_NO_NETWORK,
  SL_ZIGBEE_JOINING_NETWORK,
  SL_ZIGBEE_JOINED_NETWORK,
  SL_ZIGBEE_JOINED_NETWORK_NO_PARENT,
  SL_ZIGBEE_JOINED_NETWORK_S2S_INITIATOR,
  SL_ZIGBEE_JOINED_NETWORK_S2S_TARGET,
  SL_ZIGBEE_LEAVING_NETWORK
};

// The RADIO_OFF scan is not really a scan at all.  It is used to
// temporarily turn off the radio to use the TX and RX
// buffers for other purposes.
// Start the scan with:
//   sl_zigbee_start_scan(SL_ZIGBEE_START_RADIO_OFF_SCAN, 0, 0);
// Call sl_zigbee_stop_scan() to restart the radio and the MAC.

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_network_scan_type_t
#else
typedef uint8_t sl_zigbee_network_scan_type_t;
enum
#endif
{
  SL_ZIGBEE_ENERGY_SCAN,
  SL_ZIGBEE_ACTIVE_SCAN,
  SL_ZIGBEE_START_RADIO_OFF_SCAN,
  SL_ZIGBEE_STACK_GP_CHANNEL_DELIVERY_SCAN,
  SL_ZIGBEE_ACTIVE_SCAN_ROUTER,
  SL_ZIGBEE_LAST_SCAN_TYPE = SL_ZIGBEE_ACTIVE_SCAN_ROUTER
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_binding_type_t
#else
typedef uint8_t sl_zigbee_binding_type_t;
enum
#endif
{
  SL_ZIGBEE_UNUSED_BINDING         = 0,
  SL_ZIGBEE_UNICAST_BINDING        = 1,
  SL_ZIGBEE_MANY_TO_ONE_BINDING    = 2,
  SL_ZIGBEE_MULTICAST_BINDING      = 3,
};

#define SL_ZIGBEE_INACTIVE_CONCENTRATOR 0xFFFFu
#define SL_ZIGBEE_LOW_RAM_CONCENTRATOR 0xFFF8u
#define SL_ZIGBEE_HIGH_RAM_CONCENTRATOR 0xFFF9u


#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_assume_trust_center_concentrator_type_t
#else
typedef uint8_t sl_zigbee_assume_trust_center_concentrator_type_t;
enum
#endif
{
  SL_ZIGBEE_ASSUME_TRUST_CENTER_IS_NOT_A_CONCENTRATOR = 0,
  SL_ZIGBEE_ASSUME_TRUST_CENTER_IS_LOW_RAM_CONCENTRATOR = 1,
  SL_ZIGBEE_ASSUME_TRUST_CENTER_IS_HIGH_RAM_CONCENTRATOR = 2
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_join_decision_t
#else
typedef uint8_t sl_zigbee_join_decision_t;
enum
#endif
{
  SL_ZIGBEE_USE_PRECONFIGURED_KEY = 0,
  SL_ZIGBEE_SEND_KEY_IN_THE_CLEAR,
  SL_ZIGBEE_DENY_JOIN,
  SL_ZIGBEE_NO_ACTION,
  SL_ZIGBEE_ALLOW_REJOINS_ONLY
};

#define SL_ZIGBEE_JOIN_DECISION_STRINGS \
  "use preconfigured key",              \
  "send key in the clear",              \
  "deny join",                          \
  "no action",                          \
  "allow rejoins only",

// These map to the actual values within the APS Command frame so they cannot
// be arbitrarily changed.
#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_device_update_t
#else
typedef uint8_t sl_zigbee_device_update_t;
enum
#endif
{
  SL_ZIGBEE_STANDARD_SECURITY_SECURED_REJOIN   = 0,
  SL_ZIGBEE_STANDARD_SECURITY_UNSECURED_JOIN   = 1,
  SL_ZIGBEE_DEVICE_LEFT                        = 2,
  SL_ZIGBEE_STANDARD_SECURITY_UNSECURED_REJOIN = 3,
};

#define SL_ZIGBEE_DEVICE_UPDATE_STRINGS \
  "secured rejoin",                     \
  "UNsecured join",                     \
  "device left",                        \
  "UNsecured rejoin",

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_rejoin_reason_t
#else
typedef uint8_t sl_zigbee_rejoin_reason_t;
enum
#endif
{
  SL_ZIGBEE_REJOIN_REASON_NONE           = 0,
  SL_ZIGBEE_REJOIN_DUE_TO_NWK_KEY_UPDATE = 1,
  SL_ZIGBEE_REJOIN_DUE_TO_LEAVE_MESSAGE  = 2,
  SL_ZIGBEE_REJOIN_DUE_TO_NO_PARENT      = 3,
  SL_ZIGBEE_REJOIN_DUE_TO_ZLL_TOUCHLINK  = 4,
  SL_ZIGBEE_REJOIN_DUE_TO_END_DEVICE_REBOOT = 5,

  // App. Framework events
  // 0xA0 - 0xE0
  // See af.h for a subset of defined rejoin reasons

  // Customer-defined Events
  //   These are numbered down from 0xFF so their assigned values
  //   need not change if more application events are needed.
  SL_ZIGBEE_REJOIN_DUE_TO_APP_EVENT_5       = 0xFB,
  SL_ZIGBEE_REJOIN_DUE_TO_APP_EVENT_4       = 0xFC,
  SL_ZIGBEE_REJOIN_DUE_TO_APP_EVENT_3       = 0xFD,
  SL_ZIGBEE_REJOIN_DUE_TO_APP_EVENT_2       = 0xFE,
  SL_ZIGBEE_REJOIN_DUE_TO_APP_EVENT_1       = 0xFF,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_cluster_list_id_t
#else
typedef uint8_t sl_zigbee_cluster_list_id_t;
enum
#endif
{
  SL_ZIGBEE_INPUT_CLUSTER_LIST            = 0,
  SL_ZIGBEE_OUTPUT_CLUSTER_LIST           = 1
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_event_units_t
#else
typedef uint8_t sl_zigbee_event_units_t;
enum
#endif
{
  SL_ZIGBEE_EVENT_INACTIVE = 0,
  SL_ZIGBEE_EVENT_MS_TIME,
  SL_ZIGBEE_EVENT_QS_TIME,
  SL_ZIGBEE_EVENT_MINUTE_TIME,
  SL_ZIGBEE_EVENT_ZERO_DELAY
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_join_method_t
#else
typedef uint8_t sl_zigbee_join_method_t;
enum
#endif
{
  SL_ZIGBEE_USE_MAC_ASSOCIATION         = 0,

  SL_ZIGBEE_USE_NWK_REJOIN              = 1,

  /* For networks where the "permit joining" flag is never turned
   * on, devices will need to use a NWK Rejoin.  If those devices have been
   * preconfigured with the  NWK key (including sequence number), they can use
   * a secured rejoin.  This is only necessary for end devices since they need
   * a parent.  Routers can simply use the ::SL_ZIGBEE_USE_CONFIGURED_NWK_STATE
   * join method below.
   */
  SL_ZIGBEE_USE_NWK_REJOIN_HAVE_NWK_KEY = 2,

  SL_ZIGBEE_USE_CONFIGURED_NWK_STATE    = 3,

  SL_ZIGBEE_USE_NWK_COMMISSIONING_JOIN = 4,

  SL_ZIGBEE_USE_NWK_COMMISSIONING_REJOIN = 5,

  SL_ZIGBEE_USE_NWK_COMMISSIONING_REJOIN_HAVE_NWK_KEY = 6,
};

typedef struct {
  uint8_t   extendedPanId[EXTENDED_PAN_ID_SIZE];
  uint16_t  panId;
  int8_t   radioTxPower;
  uint8_t   radioChannel;
  sl_zigbee_join_method_t joinMethod;

  sl_802154_short_addr_t nwkManagerId;
  uint8_t nwkUpdateId;
  uint32_t channels;
} sl_zigbee_network_parameters_t;

#if defined(DOXYGEN_SHOULD_SKIP_THIS) || defined(ZNET_HEADER_SCRIPT)
#define sl_zigbee_initialize_network_parameters(parameters) \
  (memset(parameters, 0, sizeof(sl_zigbee_network_parameters_t)))
#else
void sl_zigbee_initialize_network_parameters(sl_zigbee_network_parameters_t* parameters);
#endif

typedef struct {
  int8_t radioTxPower;
  uint8_t radioPage;
  uint8_t radioChannel;
} sl_zigbee_multi_phy_radio_parameters_t;

typedef struct {
  uint16_t profileId;
  uint16_t clusterId;
  uint8_t sourceEndpoint;
  uint8_t destinationEndpoint;
  sl_zigbee_aps_option_t options;
  uint16_t groupId;
  uint8_t sequence;
  uint8_t radius;
} sl_zigbee_aps_frame_t;

typedef struct {
  sl_802154_long_addr_t eui64;
  sl_zigbee_node_type_t type;
  sl_802154_short_addr_t id;
  uint8_t phy;
  uint8_t power;
  uint8_t timeout;
  uint32_t remainingTimeout;
} sl_zigbee_child_data_t;

typedef struct {
  sl_zigbee_binding_type_t type;
  uint8_t local;
  uint16_t clusterId;
  uint8_t remote;
  sl_802154_long_addr_t identifier;
  uint8_t networkIndex;
} sl_zigbee_binding_table_entry_t;

typedef struct {
  uint16_t shortId;
  uint8_t  averageLqi;
  uint8_t  inCost;
  uint8_t  outCost;
  uint8_t  age;
  sl_802154_long_addr_t longId;
} sl_zigbee_neighbor_table_entry_t;

typedef struct {
  uint16_t destination;
  uint16_t nextHop;
  uint8_t status;
  uint8_t age;
  uint8_t concentratorType;
  uint8_t routeRecordState;
} sl_zigbee_route_table_entry_t;

typedef struct {
  sl_zigbee_multicast_id_t multicastId;
  uint8_t endpoint;
  uint8_t networkIndex;
} sl_zigbee_multicast_table_entry_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_counter_type_t
#else
typedef uint8_t sl_zigbee_counter_type_t;
enum
#endif
{
  SL_ZIGBEE_COUNTER_MAC_RX_BROADCAST = 0,
  SL_ZIGBEE_COUNTER_MAC_TX_BROADCAST = 1,
  SL_ZIGBEE_COUNTER_MAC_RX_UNICAST = 2,
  SL_ZIGBEE_COUNTER_MAC_TX_UNICAST_SUCCESS = 3,
  SL_ZIGBEE_COUNTER_MAC_TX_UNICAST_RETRY = 4,
  SL_ZIGBEE_COUNTER_MAC_TX_UNICAST_FAILED = 5,

  SL_ZIGBEE_COUNTER_APS_DATA_RX_BROADCAST = 6,
  SL_ZIGBEE_COUNTER_APS_DATA_TX_BROADCAST = 7,
  SL_ZIGBEE_COUNTER_APS_DATA_RX_UNICAST = 8,
  SL_ZIGBEE_COUNTER_APS_DATA_TX_UNICAST_SUCCESS = 9,
  SL_ZIGBEE_COUNTER_APS_DATA_TX_UNICAST_RETRY = 10,
  /* The APS layer unsuccessfully transmitted a data unicast.
   * destinationNodeId: NWK destination address
   * data: number of APS retries (>=0) consumed for this unicast.
   */
  SL_ZIGBEE_COUNTER_APS_DATA_TX_UNICAST_FAILED = 11,

  SL_ZIGBEE_COUNTER_ROUTE_DISCOVERY_INITIATED = 12,

  SL_ZIGBEE_COUNTER_NEIGHBOR_ADDED = 13,
  SL_ZIGBEE_COUNTER_NEIGHBOR_REMOVED = 14,
  SL_ZIGBEE_COUNTER_NEIGHBOR_STALE = 15,

  SL_ZIGBEE_COUNTER_JOIN_INDICATION = 16,
  SL_ZIGBEE_COUNTER_CHILD_REMOVED = 17,

  SL_ZIGBEE_COUNTER_ASH_OVERFLOW_ERROR = 18,
  SL_ZIGBEE_COUNTER_ASH_FRAMING_ERROR = 19,
  SL_ZIGBEE_COUNTER_ASH_OVERRUN_ERROR = 20,

  SL_ZIGBEE_COUNTER_NWK_FRAME_COUNTER_FAILURE = 21,

  SL_ZIGBEE_COUNTER_APS_FRAME_COUNTER_FAILURE = 22,

  SL_ZIGBEE_COUNTER_ASH_XOFF = 23,

  SL_ZIGBEE_COUNTER_APS_LINK_KEY_NOT_AUTHORIZED = 24,

  SL_ZIGBEE_COUNTER_NWK_DECRYPTION_FAILURE = 25,

  SL_ZIGBEE_COUNTER_APS_DECRYPTION_FAILURE = 26,

  SL_ZIGBEE_COUNTER_ALLOCATE_PACKET_BUFFER_FAILURE = 27,

  SL_ZIGBEE_COUNTER_RELAYED_UNICAST = 28,

  SL_ZIGBEE_COUNTER_PHY_TO_MAC_QUEUE_LIMIT_REACHED = 29,

  SL_ZIGBEE_COUNTER_PACKET_VALIDATE_LIBRARY_DROPPED_COUNT = 30,

  SL_ZIGBEE_COUNTER_TYPE_NWK_RETRY_OVERFLOW = 31,

  SL_ZIGBEE_COUNTER_PHY_CCA_FAIL_COUNT = 32,

  SL_ZIGBEE_COUNTER_BROADCAST_TABLE_FULL = 33,

  SL_ZIGBEE_COUNTER_PTA_LO_PRI_REQUESTED = 34,

  SL_ZIGBEE_COUNTER_PTA_HI_PRI_REQUESTED = 35,

  SL_ZIGBEE_COUNTER_PTA_LO_PRI_DENIED = 36,

  SL_ZIGBEE_COUNTER_PTA_HI_PRI_DENIED = 37,

  SL_ZIGBEE_COUNTER_PTA_LO_PRI_TX_ABORTED = 38,

  SL_ZIGBEE_COUNTER_PTA_HI_PRI_TX_ABORTED = 39,

  SL_ZIGBEE_COUNTER_ADDRESS_CONFLICT_SENT = 40,

  SL_ZIGBEE_COUNTER_CSL_RX_SCHEDULE_FAILED = 41,

  SL_ZIGBEE_COUNTER_TYPE_COUNT = 42,
};

typedef struct sl_802154_radio_priorities {
  uint8_t background_rx;
  uint8_t min_tx_priority;
  uint8_t tx_step;
  uint8_t max_tx_priority;
  uint8_t active_rx;
} sl_802154_radio_priorities_t;

#define SL_ZIGBEE_COUNTER_STRINGS    \
  "Mac Rx Bcast",                    \
  "Mac Tx Bcast",                    \
  "Mac Rx Ucast",                    \
  "Mac Tx Ucast",                    \
  "Mac Tx Ucast Retry",              \
  "Mac Tx Ucast Fail",               \
  "APS Rx Bcast",                    \
  "APS Tx Bcast",                    \
  "APS Rx Ucast",                    \
  "APS Tx Ucast Success",            \
  "APS Tx Ucast Retry",              \
  "APS Tx Ucast Fail",               \
  "Route Disc Initiated",            \
  "Neighbor Added",                  \
  "Neighbor Removed",                \
  "Neighbor Stale",                  \
  "Join Indication",                 \
  "Child Moved",                     \
  "ASH Overflow",                    \
  "ASH Frame Error",                 \
  "ASH Overrun Error",               \
  "NWK FC Failure",                  \
  "APS FC Failure",                  \
  "ASH XOff",                        \
  "APS Unauthorized Key",            \
  "NWK Decrypt Failures",            \
  "APS Decrypt Failures",            \
  "Packet Buffer Allocate Failures", \
  "Relayed Ucast",                   \
  "Phy to MAC queue limit reached",  \
  "Packet Validate drop count",      \
  "NWK retry overflow",              \
  "CCA Failures",                    \
  "Broadcast table full",            \
  "PTA Lo Pri Req",                  \
  "PTA Hi Pri Req",                  \
  "PTA Lo Pri Denied",               \
  "PTA Hi Pri Denied",               \
  "PTA Lo Pri Tx Abrt",              \
  "PTA Hi Pri Tx Abrt",              \
  "Address Conflict Sent",           \
  "CSL Rx schedule failed",          \
  NULL

typedef struct {
  uint8_t data;   // For now, might be number of retries or other values that previously were assigned to data.
  void *otherFields;  // For now, this might be destination nodeId, or phyIndex or both(extraCounterInfo).
} sl_zigbee_counter_info_t;

typedef struct {
  uint8_t phy_index;
  sl_802154_short_addr_t destinationNodeId;
  void *otherExtraFields;   //For now, this is NULL.
} sl_zigbee_extra_counters_info_t;

typedef uint8_t sl_zigbee_task_id_t;

//----------------------------------------------------------------
// Events and event queues.

typedef struct {
  sl_zigbee_event_units_t status;
  sl_zigbee_task_id_t taskid;
  uint32_t timeToExecute;
} sl_zigbee_event_control_t;

typedef struct {
  sl_zigbee_event_control_t *control;
  void (*handler)(void);
} sl_zigbee_event_data_t;

typedef struct {
  // The time when the next event associated with this task will fire.
  uint32_t nextEventTime;
  // The list of events associated with this task.
  sl_zigbee_event_data_t *events;
  // A flag that indicates the task has something to do other than events.
  bool busy;
} sl_zigbee_task_control_t;


#define SL_ZIGBEE_TX_POWER_MODE_DEFAULT             0x0000
#define SL_ZIGBEE_TX_POWER_MODE_BOOST               0x0001
#define SL_ZIGBEE_TX_POWER_MODE_ALTERNATE           0x0002
#define SL_ZIGBEE_TX_POWER_MODE_BOOST_AND_ALTERNATE (SL_ZIGBEE_TX_POWER_MODE_BOOST \
                                                     | SL_ZIGBEE_TX_POWER_MODE_ALTERNATE)
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// The application does not ever need to call sl_802154_set_tx_power_mode() with the
// txPowerMode parameter set to this value.  This value is used internally by
// the stack to indicate that the default token configuration has not been
// overridden by a prior call to sl_802154_set_tx_power_mode().
#define SL_ZIGBEE_TX_POWER_MODE_USE_TOKEN           0x8000
#endif //DOXYGEN_SHOULD_SKIP_THIS



#define SL_ZIGBEE_PRIVATE_PROFILE_ID  0xC00Eu

#define SL_ZIGBEE_PRIVATE_PROFILE_ID_START 0xC00Du

#define SL_ZIGBEE_PRIVATE_PROFILE_ID_END   0xC016u

#define SL_ZIGBEE_REPORT_COUNTERS_REQUEST 0x0003u

#define SL_ZIGBEE_REPORT_COUNTERS_RESPONSE 0x8003u

#define SL_ZIGBEE_REPORT_AND_CLEAR_COUNTERS_REQUEST 0x0004u

#define SL_ZIGBEE_REPORT_AND_CLEAR_COUNTERS_RESPONSE 0x8004u

#define SL_ZIGBEE_OTA_CERTIFICATE_UPGRADE_CLUSTER 0x0005u


typedef struct {
  uint8_t contents[SL_ZIGBEE_ENCRYPTION_KEY_SIZE];
} sl_zigbee_key_data_t;

typedef struct {
  uint8_t contents[SL_ZIGBEE_CERTIFICATE_SIZE];
} sl_zigbee_certificate_data_t;

typedef struct {
  uint8_t contents[SL_ZIGBEE_PUBLIC_KEY_SIZE];
} sl_zigbee_public_key_data_t;

typedef struct {
  uint8_t contents[SL_ZIGBEE_PRIVATE_KEY_SIZE];
} sl_zigbee_private_key_data_t;

typedef struct {
  uint8_t contents[SL_ZIGBEE_SMAC_SIZE];
} sl_zigbee_smac_data_t;

typedef struct {
  uint8_t contents[SL_ZIGBEE_SIGNATURE_SIZE];
} sl_zigbee_signature_data_t;

typedef struct {
  uint8_t contents[SL_ZIGBEE_AES_HASH_BLOCK_SIZE];
} sl_zigbee_message_digest_t;

typedef struct {
  uint8_t result[SL_ZIGBEE_AES_HASH_BLOCK_SIZE];
  uint32_t length;
} sl_zigbee_aes_mmo_hash_context_t;

typedef struct {
  /* This is the certificate byte data. */
  uint8_t contents[SL_ZIGBEE_CERTIFICATE_283K1_SIZE];
} sl_zigbee_certificate_283k1_data_t;

typedef struct {
  uint8_t contents[SL_ZIGBEE_PUBLIC_KEY_283K1_SIZE];
} sl_zigbee_public_key_283k1_data_t;

typedef struct {
  uint8_t contents[SL_ZIGBEE_PRIVATE_KEY_283K1_SIZE];
} sl_zigbee_private_key_283k1_data_t;

typedef struct {
  uint8_t contents[SL_ZIGBEE_SIGNATURE_283K1_SIZE];
} sl_zigbee_signature_283k1_data_t;

#define SL_ZIGBEE_STANDARD_SECURITY_MODE 0x0000

#define SL_ZIGBEE_TRUST_CENTER_NODE_ID 0x0000u

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_initial_security_bitmask_t
#else
typedef uint16_t sl_zigbee_initial_security_bitmask_t;
enum
#endif
{
  SL_ZIGBEE_DISTRIBUTED_TRUST_CENTER_MODE       = 0x0002,
  SL_ZIGBEE_TRUST_CENTER_GLOBAL_LINK_KEY        = 0x0004,
  SL_ZIGBEE_PRECONFIGURED_NETWORK_KEY_MODE      = 0x0008,

#if !defined DOXYGEN_SHOULD_SKIP_THIS
  // Hidden fields used internally.
  SL_ZIGBEE_HAVE_TRUST_CENTER_UNKNOWN_KEY_TOKEN = 0x0010,
  SL_ZIGBEE_HAVE_TRUST_CENTER_LINK_KEY_TOKEN    = 0x0020,
#endif
  SL_ZIGBEE_HAVE_TRUST_CENTER_EUI64             = 0x0040,

  SL_ZIGBEE_TRUST_CENTER_USES_HASHED_LINK_KEY   = 0x0084,

  SL_ZIGBEE_HAVE_PRECONFIGURED_KEY              = 0x0100,
  SL_ZIGBEE_HAVE_NETWORK_KEY                    = 0x0200,
  SL_ZIGBEE_GET_LINK_KEY_WHEN_JOINING           = 0x0400,
  SL_ZIGBEE_REQUIRE_ENCRYPTED_KEY               = 0x0800,
  SL_ZIGBEE_NO_FRAME_COUNTER_RESET              = 0x1000,
  SL_ZIGBEE_GET_PRECONFIGURED_KEY_FROM_INSTALL_CODE = 0x2000,

#if !defined DOXYGEN_SHOULD_SKIP_THIS
  // Internal data
  EM_SAVED_IN_TOKEN                         = 0x4000,
  #define EM_SECURITY_INITIALIZED           0x00008000L
#else
  /* All other bits are reserved and must be zero. */
#endif
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_extended_security_bitmask_t
#else
typedef uint16_t sl_zigbee_extended_security_bitmask_t;
enum
#endif
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  // If this bit is set, the 'key token data' field is set in the Initial
  // Security Bitmask to 0 (No Preconfig Key token). Otherwise, the
  // field is left as is.
  SL_ZIGBEE_PRECONFIG_KEY_NOT_VALID       = 0x0001,
#endif

  // bits 2-3 are unused.
  SL_ZIGBEE_SECURE_NETWORK_KEY_ROTATION   = 0x0002,

  SL_ZIGBEE_JOINER_GLOBAL_LINK_KEY        = 0x0010,

  SL_ZIGBEE_EXT_NO_FRAME_COUNTER_RESET    = 0x0020,

  SL_ZIGBEE_NWK_LEAVE_WITHOUT_REJOIN_NOT_ALLOWED = 0x0040,

  // Bit 7 reserved for future use (stored in TOKEN).

  SL_ZIGBEE_NWK_LEAVE_REQUEST_NOT_ALLOWED = 0x0100,

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  SL_ZIGBEE_R18_STACK_BEHAVIOR            = 0x0200,
#endif

  // Bit 10 is reserved for future use (stored in TOKEN).
  // Bit 11 is reserved for future use(stored in RAM).

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  // Bit 12 - This denotes whether an end device should discard or accept ZDO Leave
  // from a network node other than its parent.
  SL_ZIGBEE_ZDO_LEAVE_FROM_NON_PARENT_NOT_ALLOWED = 0x1000,
#endif

  // Bits 13-15 are unused.
};

#define SL_ZIGBEE_TC_SUPPORTS_FC_SYNC   0x00800000UL

#define SL_ZIGBEE_NO_TRUST_CENTER_MODE   SL_ZIGBEE_DISTRIBUTED_TRUST_CENTER_MODE

#define SL_ZIGBEE_GLOBAL_LINK_KEY   SL_ZIGBEE_TRUST_CENTER_GLOBAL_LINK_KEY

#if !defined DOXYGEN_SHOULD_SKIP_THIS
  #define NO_TRUST_CENTER_KEY_TOKEN        0x0000
  #define TRUST_CENTER_KEY_TOKEN_MASK      0x0030
  #define SECURITY_BIT_TOKEN_MASK          0x71FF
// If this bit is on, it indicates that the TC token does not hold the TC key
// It lives in PSA at a fixed ID (see ZB SM)
  #define TRUST_CENTER_KEY_LIVES_IN_PSA    0x8000

  #define SECURITY_LOWER_BIT_MASK          0x000000FF  // ""
  #define SECURITY_UPPER_BIT_MASK          0x00FF0000L // ""
#endif

typedef struct {
  uint16_t bitmask;
  sl_zigbee_key_data_t preconfiguredKey;
  sl_zigbee_key_data_t networkKey;
  uint8_t networkKeySequenceNumber;
  sl_802154_long_addr_t preconfiguredTrustCenterEui64;
} sl_zigbee_initial_security_state_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_current_security_bitmask_t
#else
typedef uint16_t sl_zigbee_current_security_bitmask_t;
enum
#endif
{
#if defined DOXYGEN_SHOULD_SKIP_THIS
  // These options are the same for Initial and Current Security state.

  SL_ZIGBEE_STANDARD_SECURITY_MODE_             = 0x0000,
  SL_ZIGBEE_DISTRIBUTED_TRUST_CENTER_MODE_      = 0x0002,
  SL_ZIGBEE_TRUST_CENTER_GLOBAL_LINK_KEY_       = 0x0004,
#else
  // Bit 3 reserved
#endif
  SL_ZIGBEE_HAVE_TRUST_CENTER_LINK_KEY          = 0x0010,

  SL_ZIGBEE_TRUST_CENTER_USES_HASHED_LINK_KEY_   = 0x0084,

  // Bits 1, 5, 6, and 8-15 reserved.
};

#if !defined DOXYGEN_SHOULD_SKIP_THIS
  #define INITIAL_AND_CURRENT_BITMASK         0x00FF
#endif

typedef struct {
  sl_zigbee_current_security_bitmask_t bitmask;
  sl_802154_long_addr_t trustCenterLongAddress;
} sl_zigbee_current_security_state_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_key_struct_bitmask_t
#else
typedef uint16_t sl_zigbee_key_struct_bitmask_t;
enum
#endif
{
  SL_ZIGBEE_KEY_HAS_SEQUENCE_NUMBER        = 0x0001,
  SL_ZIGBEE_KEY_HAS_OUTGOING_FRAME_COUNTER = 0x0002,
  SL_ZIGBEE_KEY_HAS_INCOMING_FRAME_COUNTER = 0x0004,
  SL_ZIGBEE_KEY_HAS_PARTNER_EUI64          = 0x0008,
  SL_ZIGBEE_KEY_IS_AUTHORIZED              = 0x0010,
  SL_ZIGBEE_KEY_PARTNER_IS_SLEEPY          = 0x0020,
  SL_ZIGBEE_UNCONFIRMED_TRANSIENT_KEY      = 0x0040,
  SL_ZIGBEE_KEY_HAS_PSA_ID                 = 0x0080,
  SL_ZIGBEE_KEY_HAS_KEY_DATA               = 0x0100,
  SL_ZIGBEE_KEY_IS_AUTHENTICATION_TOKEN    = 0x0200,
  SL_ZIGBEE_DLK_DERIVED_KEY                = 0x0400,
  SL_ZIGBEE_KEY_FC_SYNC_SUPPORTED           = 0x0800,
};

typedef struct {
  sl_802154_long_addr_t eui64;
  uint32_t incomingFrameCounter;
  sl_zigbee_key_struct_bitmask_t bitmask;
  uint16_t remainingTimeSeconds;
  uint8_t networkIndex;
  union {
    sl_zigbee_key_data_t keyData; // valid only if bitmask & SL_ZIGBEE_KEY_HAS_KEY_DATA (on some parts, keys are stored in secure storage and not RAM)
    uint32_t psa_id;      // valid only if bitmask & SL_ZIGBEE_KEY_HAS_PSA_ID (on some parts, keys are stored in secure storage and not RAM)
  };
} sl_zigbee_transient_key_data_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_key_type_t
#else
typedef uint8_t sl_zigbee_key_type_t;
enum
#endif
{
  SL_ZIGBEE_TRUST_CENTER_LINK_KEY         = 1,
  SL_ZIGBEE_CURRENT_NETWORK_KEY           = 3,
  SL_ZIGBEE_NEXT_NETWORK_KEY              = 4,
  SL_ZIGBEE_APPLICATION_LINK_KEY          = 5,
};

typedef struct {
  sl_zigbee_key_struct_bitmask_t bitmask;
  sl_zigbee_key_type_t type;
  union {
    sl_zigbee_key_data_t key;
    uint32_t psa_id;
  };
  uint32_t outgoingFrameCounter;
  uint32_t incomingFrameCounter;
  uint8_t sequenceNumber;
  sl_802154_long_addr_t partnerEUI64;
} sl_zigbee_key_struct_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_key_status_t
#else
typedef uint8_t sl_zigbee_key_status_t;
enum
#endif
{
  SL_ZIGBEE_KEY_STATUS_NONE                    = 0x00,
  SL_ZIGBEE_APP_LINK_KEY_ESTABLISHED           = 0x01,
  SL_ZIGBEE_TRUST_CENTER_LINK_KEY_ESTABLISHED  = 0x03,

  SL_ZIGBEE_KEY_ESTABLISHMENT_TIMEOUT          = 0x04,
  SL_ZIGBEE_KEY_TABLE_FULL                     = 0x05,

  // These are success status values applying only to the
  // Trust Center answering key requests.
  SL_ZIGBEE_TC_RESPONDED_TO_KEY_REQUEST        = 0x06,
  SL_ZIGBEE_TC_APP_KEY_SENT_TO_REQUESTER       = 0x07,

  // These are failure status values applying only to the
  // Trust Center answering key requests.
  SL_ZIGBEE_TC_RESPONSE_TO_KEY_REQUEST_FAILED  = 0x08,
  SL_ZIGBEE_TC_REQUEST_KEY_TYPE_NOT_SUPPORTED  = 0x09,
  SL_ZIGBEE_TC_NO_LINK_KEY_FOR_REQUESTER       = 0x0A,
  SL_ZIGBEE_TC_REQUESTER_EUI64_UNKNOWN         = 0x0B,
  SL_ZIGBEE_TC_RECEIVED_FIRST_APP_KEY_REQUEST  = 0x0C,
  SL_ZIGBEE_TC_TIMEOUT_WAITING_FOR_SECOND_APP_KEY_REQUEST = 0x0D,
  SL_ZIGBEE_TC_NON_MATCHING_APP_KEY_REQUEST_RECEIVED      = 0x0E,
  SL_ZIGBEE_TC_FAILED_TO_SEND_APP_KEYS         = 0x0F,
  SL_ZIGBEE_TC_FAILED_TO_STORE_APP_KEY_REQUEST = 0x10,
  SL_ZIGBEE_TC_REJECTED_APP_KEY_REQUEST        = 0x11,
  SL_ZIGBEE_TC_FAILED_TO_GENERATE_NEW_KEY      = 0x12,
  SL_ZIGBEE_TC_FAILED_TO_SEND_TC_KEY           = 0x13,

  // These are generic status values for a key requester.
  SL_ZIGBEE_TRUST_CENTER_IS_PRE_R21            = 0x1E,

  // These are status values applying only to the Trust Center
  // verifying link keys.
  SL_ZIGBEE_TC_REQUESTER_VERIFY_KEY_TIMEOUT    = 0x32,
  SL_ZIGBEE_TC_REQUESTER_VERIFY_KEY_FAILURE    = 0x33,
  SL_ZIGBEE_TC_REQUESTER_VERIFY_KEY_SUCCESS    = 0x34,

  // These are status values applying only to the key requester
  // verifying link keys.
  SL_ZIGBEE_VERIFY_LINK_KEY_FAILURE            = 0x64,
  SL_ZIGBEE_VERIFY_LINK_KEY_SUCCESS            = 0x65,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_tc_link_key_request_policy_t
#else
typedef uint8_t sl_zigbee_tc_link_key_request_policy_t;
enum
#endif
{
  SL_ZIGBEE_DENY_TC_LINK_KEY_REQUESTS  = 0x00,
  SL_ZIGBEE_ALLOW_TC_LINK_KEY_REQUEST_AND_SEND_CURRENT_KEY = 0x01,
  // When using the following mode a unique random link key is created.
  // The key which is generated due to this mode is added to the link
  // key table. Therefore make sure that the link key table size is not
  // zero as this can result in the newly generated key not being saved
  // and communication breaking between the trust center and the nodes.
  SL_ZIGBEE_ALLOW_TC_LINK_KEY_REQUEST_AND_GENERATE_NEW_KEY = 0x02
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_app_link_key_request_policy_t
#else
typedef uint8_t sl_zigbee_app_link_key_request_policy_t;
enum
#endif
{
  SL_ZIGBEE_DENY_APP_LINK_KEY_REQUESTS  = 0x00,
  SL_ZIGBEE_ALLOW_APP_LINK_KEY_REQUEST = 0x01
};

#if defined DOXYGEN_SHOULD_SKIP_THIS
uint8_t* sl_zigbee_key_contents(sl_zigbee_key_data_t *key);
#else
#define sl_zigbee_key_contents(key) ((key)->contents)
#endif

#if defined DOXYGEN_SHOULD_SKIP_THIS
uint8_t* sl_zigbee_certificate_contents(sl_zigbee_certificate_data_t *cert);
#else
#define sl_zigbee_certificate_contents(cert) ((cert)->contents)
#endif

#if defined DOXYGEN_SHOULD_SKIP_THIS
uint8_t* sl_zigbee_public_key_contents(sl_zigbee_public_key_data_t *key);
#else
#define sl_zigbee_public_key_contents(key) ((key)->contents)
#endif

#if defined DOXYGEN_SHOULD_SKIP_THIS
uint8_t* sl_zigbee_private_key_contents(sl_zigbee_private_key_data_t *key);
#else
#define sl_zigbee_private_key_contents(key) ((key)->contents)
#endif

#if defined DOXYGEN_SHOULD_SKIP_THIS
uint8_t* sl_zigbee_smac_contents(sl_zigbee_smac_data_t *key);
#else
#define sl_zigbee_smac_contents(key) ((key)->contents)
#endif

#if defined DOXYGEN_SHOULD_SKIP_THIS
uint8_t* sl_zigbee_signature_contents(sl_zigbee_signature_data_t *sig);
#else
#define sl_zigbee_signature_contents(sig) ((sig)->contents)
#endif

#if defined DOXYGEN_SHOULD_SKIP_THIS
uint8_t* sl_zigbee_certificate_283k1_contents(sl_zigbee_certificate_283k1_data_t *cert);
#else
#define sl_zigbee_certificate_283k1_contents(cert) ((cert)->contents)
#endif

#if defined DOXYGEN_SHOULD_SKIP_THIS
uint8_t* sl_zigbee_public_key_283k1_contents(sl_zigbee_public_key_283k1_data_t *key);
#else
#define sl_zigbee_public_key_283k1_contents(key) ((key)->contents)
#endif

#if defined DOXYGEN_SHOULD_SKIP_THIS
uint8_t* sl_zigbee_private_key_283k1_contents(sl_zigbee_private_key_283k1_data_t *key);
#else
#define sl_zigbee_private_key_283k1_contents(key) ((key)->contents)
#endif

#if defined DOXYGEN_SHOULD_SKIP_THIS
uint8_t* ember283k1SignatureContents(sl_zigbee_signature_283k1_data_t *sig);
#else
#define ember283k1SignatureContents(sig) ((sig)->contents)
#endif

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_key_settings_t
#else
typedef uint16_t sl_zigbee_key_settings_t;
enum
#endif
{
  SL_ZIGBEE_KEY_PERMISSIONS_NONE            = 0x0000,
  SL_ZIGBEE_KEY_PERMISSIONS_READING_ALLOWED = 0x0001,
  SL_ZIGBEE_KEY_PERMISSIONS_HASHING_ALLOWED = 0x0002,
};

typedef struct {
  sl_zigbee_key_settings_t keySettings;
} sl_zigbee_mfg_security_struct_t;

#define SL_LEGACY_SECURITY_CONFIG_MAGIC_NUMBER 0xCABAD11FUL

typedef struct {
  sl_zigbee_duty_cycle_hecto_pct_t limitThresh;
  sl_zigbee_duty_cycle_hecto_pct_t critThresh;
  sl_zigbee_duty_cycle_hecto_pct_t suspLimit;
} sl_zigbee_duty_cycle_limits_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_duty_cycle_state_t
#else
typedef uint8_t sl_zigbee_duty_cycle_state_t;
enum
#endif
{
  SL_ZIGBEE_DUTY_CYCLE_TRACKING_OFF                    = 0,
  SL_ZIGBEE_DUTY_CYCLE_LBT_NORMAL                      = 1,
  SL_ZIGBEE_DUTY_CYCLE_LBT_LIMITED_THRESHOLD_REACHED   = 2,
  SL_ZIGBEE_DUTY_CYCLE_LBT_CRITICAL_THRESHOLD_REACHED  = 3,
  SL_ZIGBEE_DUTY_CYCLE_LBT_SUSPEND_LIMIT_REACHED       = 4,
};

typedef struct {
  sl_802154_short_addr_t nodeId;
  sl_zigbee_duty_cycle_hecto_pct_t dutyCycleConsumed;
} sl_zigbee_per_device_duty_cycle_t;

typedef struct {
  sl_802154_short_addr_t nwk_short_address;
  uint8_t bitmask;
  uint8_t mac_interface_id;
  uint8_t nwk_index;
  uint8_t *network_packet;
  uint8_t network_packet_length;
} sl_nwk_packet_exchange_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_mac_passthrough_type_t
#else
typedef uint8_t sl_zigbee_mac_passthrough_type_t;
enum
#endif
{
  SL_802154_PASSTHROUGH_NONE             = 0x00,
  SL_802154_PASSTHROUGH_SE_INTERPAN      = 0x01,
  SL_802154_PASSTHROUGH_EMBERNET         = 0x02,
  SL_802154_PASSTHROUGH_EMBERNET_SOURCE  = 0x04,
  SL_802154_PASSTHROUGH_APPLICATION      = 0x08,
  SL_802154_PASSTHROUGH_CUSTOM           = 0x10,

#if !defined DOXYGEN_SHOULD_SKIP_THIS
  EM_MAC_PASSTHROUGH_INTERNAL_ZLL        = 0x80,
  EM_MAC_PASSTHROUGH_INTERNAL_GP         = 0x40
#endif
};

typedef struct {
  uint8_t filterIndexMatch;
  sl_zigbee_mac_passthrough_type_t legacyPassthroughType;
  sli_buffer_manager_buffer_t message;
} sl_zigbee_mac_filter_match_struct_t;


#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_zdo_status_t
#else
typedef uint8_t sl_zigbee_zdo_status_t;
enum
#endif
{
  // These values are taken from Table 48 of ZDP Errata 043238r003 and Table 2
  // of NWK 02130r10.
  SL_ZIGBEE_ZDP_SUCCESS                    = 0x00,
  // 0x01 to 0x7F are reserved
  SL_ZIGBEE_ZDP_INVALID_REQUEST_TYPE       = 0x80,
  SL_ZIGBEE_ZDP_DEVICE_NOT_FOUND           = 0x81,
  SL_ZIGBEE_ZDP_INVALID_ENDPOINT           = 0x82,
  SL_ZIGBEE_ZDP_NOT_ACTIVE                 = 0x83,
  SL_ZIGBEE_ZDP_NOT_SUPPORTED              = 0x84,
  SL_ZIGBEE_ZDP_TIMEOUT                    = 0x85,
  SL_ZIGBEE_ZDP_NO_MATCH                   = 0x86,
  // 0x87 is reserved                  = 0x87,
  SL_ZIGBEE_ZDP_NO_ENTRY                   = 0x88,
  SL_ZIGBEE_ZDP_NO_DESCRIPTOR              = 0x89,
  SL_ZIGBEE_ZDP_INSUFFICIENT_SPACE         = 0x8a,
  SL_ZIGBEE_ZDP_NOT_PERMITTED              = 0x8b,
  SL_ZIGBEE_ZDP_TABLE_FULL                 = 0x8c,
  SL_ZIGBEE_ZDP_NOT_AUTHORIZED             = 0x8d,
  SL_ZIGBEE_ZDP_DEVICE_BINDING_TABLE_FULL  = 0x8e,
  SL_ZIGBEE_ZDP_INVALID_INDEX              = 0x8f,
  SL_ZIGBEE_ZDP_FRAME_TOO_LARGE            = 0x90,
  SL_ZIGBEE_ZDP_BAD_KEY_NEGOTIATION_METHOD = 0x91,
  SL_ZIGBEE_ZDP_TEMPORARY_FAILURE          = 0x92,

  SL_ZIGBEE_APS_SECURITY_FAIL              = 0xad,

  SL_ZIGBEE_NWK_ALREADY_PRESENT            = 0xc5,
  SL_ZIGBEE_NWK_TABLE_FULL                 = 0xc7,
  SL_ZIGBEE_NWK_UNKNOWN_DEVICE             = 0xc8,

  SL_ZIGBEE_NWK_MISSING_TLV                = 0xd6,
  SL_ZIGBEE_NWK_INVALID_TLV                = 0xd7,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_zdo_server_mask_t
#else
typedef uint16_t sl_zigbee_zdo_server_mask_t;
enum
#endif
{
  SL_ZIGBEE_ZDP_PRIMARY_TRUST_CENTER          = 0x0001,
  SL_ZIGBEE_ZDP_SECONDARY_TRUST_CENTER        = 0x0002,
  SL_ZIGBEE_ZDP_PRIMARY_BINDING_TABLE_CACHE   = 0x0004,
  SL_ZIGBEE_ZDP_SECONDARY_BINDING_TABLE_CACHE = 0x0008,
  SL_ZIGBEE_ZDP_PRIMARY_DISCOVERY_CACHE       = 0x0010, 
  SL_ZIGBEE_ZDP_SECONDARY_DISCOVERY_CACHE     = 0x0020, 
  SL_ZIGBEE_ZDP_NETWORK_MANAGER               = 0x0040,
  // Bits 0x0080 to 0x8000 are reserved.
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_zdo_configuration_flags_t
#else
typedef uint8_t sl_zigbee_zdo_configuration_flags_t;
enum
#endif

{
  SL_ZIGBEE_APP_RECEIVES_SUPPORTED_ZDO_REQUESTS  = 0x01,
  SL_ZIGBEE_APP_HANDLES_UNSUPPORTED_ZDO_REQUESTS = 0x02,
  SL_ZIGBEE_APP_HANDLES_ZDO_ENDPOINT_REQUESTS    = 0x04,
  SL_ZIGBEE_APP_HANDLES_ZDO_BINDING_REQUESTS     = 0x08
};


typedef struct {
  sl_802154_short_addr_t destination;        // SL_ZIGBEE_NULL_NODE_ID if entry is marked for removal
  uint8_t closerIndex;            // The entry one hop closer to the gateway.
  uint8_t olderIndex;             // The entry touched before this one.
} sl_zigbee_source_route_table_entry_t;

#if defined(SL_ZIGBEE_SCRIPTED_TEST)
#define WEAK_TEST WEAK()//__attribute__((weak))
#else
#define WEAK_TEST
#endif

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_multi_phy_nwk_config_t
#else
typedef uint8_t sl_zigbee_multi_phy_nwk_config_t;
enum
#endif
{
  SL_ZIGBEE_MULTI_PHY_ROUTERS_ALLOWED = 0x01,
  SL_ZIGBEE_MULTI_PHY_BROADCASTS_ENABLED = 0x02,
  SL_ZIGBEE_MULTI_PHY_DISABLED = 0x80
};

#define SL_ZIGBEE_MAX_MAC_ONLY_COUNTERS 33u

#define SL_ZIGBEE_MAX_NUM_PHYS 2u

#define PHY_INDEX_NATIVE        0u

#define PHY_INDEX_PRO2PLUS      1u

typedef uint8_t sl_zigbee_radio_power_mode_t;

typedef struct {
  int8_t minRssiForReceivingPkts;
  uint16_t beaconClassificationMask;
} sl_zigbee_beacon_classification_params_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_beacon_classification_flags_t
#else
typedef uint16_t sl_zigbee_beacon_classification_flags_t;
enum
#endif
{
  NO_PARENT_CLASSIFICATION_AND_NO_TC_CONNECTIVITY_PRIORITY = 0x0000, // this indicates that the classification mode is disabled
  PRIORITIZE_BEACONS_BASED_ON_PARENT_CLASSIFICATION  = 0x0001,  // this means we also advertise the TC connectivity and long/short uptime
  PRIORITIZE_BEACONS_BASED_ON_TC_CONNECTVITY  = 0x0002,   //this means we also advertise TC connectivity
  // The following two bits are only ADVERTISED in a beacon if Parent Classification
  // is enabled (bit 0), or tcBasedCassification (bit 1) is enabled
  TC_CONNECTIVITY       = 0x0010,
  LONG_UPTIME            = 0x0020,
  BAD_PARENT_CONNECTIVITY = 0x0040, // it indicates if the paren connection is bad.
  // Meaning rolling avg of RSSI over the last window of packets (16 for now) have been
  // lower than minRssiForReceivingPkts.
  // The rolling average is (re)initiated after the last successful (re)join.
  PREFERRED_PARENT        = 0x60  // This is information we provide for routers.
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_entropy_source_t
#else
typedef uint8_t sl_zigbee_entropy_source_t;
enum
#endif
{
  SL_ZIGBEE_ENTROPY_SOURCE_ERROR        = 0x00, // Error in identifying the entropy source.
  SL_ZIGBEE_ENTROPY_SOURCE_RADIO        = 0x01, // The default radio entropy source.
  SL_ZIGBEE_ENTROPY_SOURCE_MBEDTLS_TRNG = 0x02, // TRNG with mbed TLS support.
  SL_ZIGBEE_ENTROPY_SOURCE_MBEDTLS      = 0x03, // Other mbed TLS entropy source.
};

enum {
  SL_ZIGBEE_POLL_TIMEOUT_10_SECONDS    =  0,
  SL_ZIGBEE_POLL_TIMEOUT_2_MINUTES     =  1,
  SL_ZIGBEE_POLL_TIMEOUT_4_MINUTES     =  2,
  SL_ZIGBEE_POLL_TIMEOUT_8_MINUTES     =  3,
  SL_ZIGBEE_POLL_TIMEOUT_16_MINUTES    =  4,
  SL_ZIGBEE_POLL_TIMEOUT_32_MINUTES    =  5,
  SL_ZIGBEE_POLL_TIMEOUT_64_MINUTES    =  6,
  SL_ZIGBEE_POLL_TIMEOUT_128_MINUTES   =  7,
  SL_ZIGBEE_POLL_TIMEOUT_256_MINUTES   =  8,
  SL_ZIGBEE_POLL_TIMEOUT_512_MINUTES   =  9,
  SL_ZIGBEE_POLL_TIMEOUT_1024_MINUTES  = 10,
  SL_ZIGBEE_POLL_TIMEOUT_2048_MINUTES  = 11,
  SL_ZIGBEE_POLL_TIMEOUT_4096_MINUTES  = 12,
  SL_ZIGBEE_POLL_TIMEOUT_8192_MINUTES  = 13,
  SL_ZIGBEE_POLL_TIMEOUT_16384_MINUTES = 14,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_tc_aps_encrypt_mode_t
#else
typedef uint8_t sl_zigbee_tc_aps_encrypt_mode_t;
enum
#endif
{
  TC_APS_ENCRYPT_DEFAULT = 0x00,
  TC_APS_ENCRYPT_ENABLE = 0x01,
  TC_APS_ENCRYPT_DISABLE = 0x02,
};

typedef struct {
  uint32_t nvm3Key;
  bool isCnt;
  bool isIdx;
  uint8_t size;
  uint8_t arraySize;
} sl_zigbee_token_info_t;

typedef struct {
  uint32_t size;
  void *data;
} sl_zigbee_token_data_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_keep_alive_mode_t
#else
typedef uint8_t sl_zigbee_keep_alive_mode_t;
enum
#endif
{
  SL_ZIGBEE_KEEP_ALIVE_SUPPORT_UNKNOWN     = 0x00,
  SL_802154_DATA_POLL_KEEP_ALIVE       = 0x01,
  SL_ZIGBEE_END_DEVICE_TIMEOUT_KEEP_ALIVE  = 0x02,
  SL_ZIGBEE_KEEP_ALIVE_SUPPORT_ALL         = 0x03,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_source_route_discovery_mode_t
#else
typedef uint8_t sl_zigbee_source_route_discovery_mode_t;
enum
#endif
{
  SL_ZIGBEE_SOURCE_ROUTE_DISCOVERY_OFF = 0x00,
  SL_ZIGBEE_SOURCE_ROUTE_DISCOVERY_ON = 0x01,
  SL_ZIGBEE_SOURCE_ROUTE_DISCOVERY_RESCHEDULE = 0x02,
};

#define SL_ZIGBEE_SOURCE_ROUTE_OVERHEAD_UNKNOWN 0xFFu

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_transmit_priority_t
#else
typedef uint8_t sl_zigbee_transmit_priority_t;
enum
#endif
{
  SL_802154_TRANSMIT_PRIORITY_HIGH,
  SL_802154_TRANSMIT_PRIORITY_NORMAL,
  SL_802154_TRANSMIT_PRIORITY_SCAN_OKAY
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_route_record_policy_type_t
#else
typedef uint8_t sl_zigbee_route_record_policy_type_t;
enum
#endif
{
  ROUTE_RECORD_POLICY_ACK_BY_SOURCE_ROUTED_MESSAGE           = 0,
  ROUTE_RECORD_POLICY_DONT_SEND               = 1,
  ROUTE_RECORD_POLICY_NO_ACK_REQUIRED = 2,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_passive_ack_config_enum_t
#else
typedef uint8_t sl_passive_ack_config_enum_t;
enum
#endif
{
  SL_PASSIVE_ACK_DEFAULT_CONFIG = 0,
  SL_PASSIVE_ACK_DISABLE,
  SL_PASSIVE_ACK_THRESHOLD_WITH_REBROADCAST,
  SL_PASSIVE_ACK_THRESHOLD_NO_REBROADCAST,
  SL_PASSIVE_ACK_THRESHOLD_WITH_REBROADCAST_ALL_NODES
};

typedef struct aps_duplicate_msg_entry {
  uint32_t crc_digest;
} sl_zigbee_aps_duplicate_msg_entry_t;

// an entry in the neighbor table.  nodes directly measure the incoming
// link quality, but rely on the neighbors to tell them their outgoing link
// quality.
//
// we use an uint16_t rather than an uint8_t for the incoming link quality
// value in order to have the needed precision to perform rolling averages.
//
// the age field is incremented every neighbor exchange period, and set
// to zero upon reception of a neighbor exchange message which lists us.
// thus it indicates the time since last obtaining a valid outgoing cost.
//
// the overlap count is used in the neighbor selection algorithm
// to favor neighborhoods that have low overlap with ours.
//
// the active network key bit is used to indicate whether our neighbors
// are using the active network key (my key) or the alternate
// one.  this is important for knowing when to reset their frame counter.
// for children's frame counters, see 'child.h'.

// the neighbor association bit indicates whether the device was added to the
// neighbor table because it associated to the local node (vs link status
// message).  it is used to help pick which neighbor to remove from the
// neighbor table.

typedef struct {
  sl_802154_short_addr_t id;
  uint16_t incoming;
  uint8_t exchange;      // 0xf0 age in neighbor exchange periods
                         // 0x07 outgoing cost (bottom 3 bits)
                         // bit 0x08 is unused
  uint8_t connectivity;  // overlap in bits 0,1
                         // bits 2 and 3 are used to store information about
                         // the previous incoming cost which can be 1,3,5,7
                         // neighbor using my active network key in bit 4
                         // bit 5 is reserved
                         // neighbor association in bit 6
                         // neighbor security capability in bit 7 (1 = high,
                         //   0 = standard)
  sl_802154_long_addr_t eui64;
  uint8_t mac_interface_table_index;
  uint8_t lqi_for_median[3];
} sl_zigbee_neighbor_table_entry_info_t;

typedef struct {
  uint16_t source;
  uint8_t  sequence;
  uint8_t  numAcks;
  uint32_t neighborBitmask;
} sl_zigbee_broadcast_table_entry_t;

typedef struct {
  // Child Table Info
  sl_mac_child_entry_t *childTable;
  uint16_t *childStatus;
  uint32_t *childTimers;
  uint16_t *childLqi;

  // Routing Table Info
  uint8_t *routeRecordTable;

  // Child Table End Device Info
  uint8_t *endDeviceTimeout;
  uint8_t endDeviceChildCount;

  // Used for sending link status more quickly at startup
  // and only used by routers.
  uint8_t fastLinkStatusCount;

  // Broadcast Table Info
  uint8_t broadcastHead;
  uint8_t inInitialBroadcastTimeout;
  uint32_t broadcastAgeCutoffIndexes;
  sl_zigbee_broadcast_table_entry_t *broadcastTable;

  // Association info
  bool permitJoining;
  bool macPermitAssociation;
  bool allowRejoinsWithWellKnownKey;

  // Parent announcement
  uint8_t parentAnnounceIndex;
  uint8_t totalInitialChildren;

  // PanId conflict info
  sl_802154_pan_id_t newPanId;
} sl_zigbee_pan_info_t;

typedef struct {
  uint8_t stackProfile;
  uint8_t nodeType;
  uint8_t zigbeeState;
  uint8_t dynamicCapabilities;

  uint8_t zigbeeNetworkSecurityLevel;
  uint32_t securityStateBitmask;
  uint8_t zigbeeSequenceNumber;
  uint8_t apsSequenceNumber;

  // Network security stuff
  uint8_t securityKeySequenceNumber;
  uint32_t nextNwkFrameCounter;

  // APS security stuff
  uint32_t incomingTcLinkKeyFrameCounter;

  // Neighbor table
  sl_zigbee_neighbor_table_entry_info_t *neighborTable;
  uint8_t neighborTableSize;
  uint8_t neighborCount;

  // Incoming frame counters table
  uint32_t* frameCounters;

  // The number of ticks since our last successful poll.  Ticks are
  // in seconds.
  uint32_t ticksSinceLastPoll; // for timing out our parent
  uint32_t msSinceLastPoll;   // for APS retry timeout adjustment

  // Transmission statistics that are reported in NWK_UPDATE_RESPONSE ZDO
  // messages.
  uint16_t unicastTxAttempts;
  uint16_t unicastTxFailures;
  uint16_t parentNwkInformation;

  // Child aging stuff
  //----------------------------------------------------------------
  // The last time we updated the child timers for each unit.
  // The milliseconds needs to be larger because we use it on children, who
  // may go a long time between calls to sl_zigbee_tick().
  uint16_t lastChildAgeTimeSeconds;
  uint32_t lastChildAgeTimeMs;

  // PAN info contains collection of elements needed to accommodate
  // single network, multi network and multi PAN use cases.
  sl_zigbee_pan_info_t *panInfoData;
} sl_zigbee_network_info_t;

// Note:
// For single network case:
//  - sl_zigbee_network_info_t and sli_zigbee_pan_info: Single instance present.
// For multi network case:
//  - sl_zigbee_network_info_t: Instance present for each network.
//  - sli_zigbee_pan_info: Single Instance present.
// For multi PAN case"
//  - sl_zigbee_network_info_t and sli_zigbee_pan_info: Instance present for each network.

#define MANUFACTURING_STRING_SIZE            16
typedef uint8_t sl_zigbee_manufacturing_string_t[MANUFACTURING_STRING_SIZE];

typedef struct {
  uint16_t profileId;
  uint16_t deviceId;
  uint8_t deviceVersion;
  uint8_t inputClusterCount;
  uint8_t outputClusterCount;
} sl_zigbee_endpoint_description_t;

typedef struct {
  uint16_t max_incoming_transfer_size;
  uint16_t max_outgoing_transfer_size;
  uint8_t capability;
} sl_zigbee_node_descriptor_info_t;

typedef struct {
  sl_802154_short_addr_t sender_short_id;
  sl_802154_long_addr_t sender_long_id;
  uint8_t binding_index;
  uint8_t address_index;
  uint8_t last_hop_lqi;
  int8_t last_hop_rssi;
  /* Timestamp of the moment when Start Frame Delimiter (SFD) was received */
  uint32_t last_hop_timestamp;
} sl_zigbee_rx_packet_info_t;

// Note:
// For single network case:
//  - sl_zigbee_network_info_t and sli_zigbee_pan_info: Single instance present.
// For multi network case:
//  - sl_zigbee_network_info_t: Instance present for each network.
//  - sli_zigbee_pan_info: Single Instance present.
// For multi PAN case"
//  - sl_zigbee_network_info_t and sli_zigbee_pan_info: Instance present for each network.

#endif // SLABS_EMBER_TYPES_H

#include "stack/include/zll-types.h"
#include "stack/include/gp-types.h"
#include "stack/include/zigbee-security-manager-types.h"

Modules#

sl_zigbee_release_type_struct_t

sl_zigbee_version_t

sl_zigbee_zigbee_network_t

sl_zigbee_network_init_struct_t

sl_zigbee_beacon_survey_t

sl_zigbee_beacon_data_t

sl_zigbee_network_parameters_t

sl_zigbee_multi_phy_radio_parameters_t

sl_zigbee_aps_frame_t

sl_zigbee_child_data_t

sl_zigbee_binding_table_entry_t

sl_zigbee_neighbor_table_entry_t

sl_zigbee_route_table_entry_t

sl_zigbee_multicast_table_entry_t

sl_802154_radio_priorities

sl_zigbee_counter_info_t

sl_zigbee_extra_counters_info_t

sl_zigbee_event_control_t

sl_zigbee_event_data_t

sl_zigbee_task_control_t

sl_zigbee_key_data_t

sl_zigbee_certificate_data_t

sl_zigbee_public_key_data_t

sl_zigbee_private_key_data_t

sl_zigbee_smac_data_t

sl_zigbee_signature_data_t

sl_zigbee_message_digest_t

sl_zigbee_aes_mmo_hash_context_t

sl_zigbee_certificate_283k1_data_t

sl_zigbee_public_key_283k1_data_t

sl_zigbee_private_key_283k1_data_t

sl_zigbee_signature_283k1_data_t

sl_zigbee_initial_security_state_t

sl_zigbee_current_security_state_t

sl_zigbee_transient_key_data_t

sl_zigbee_key_struct_t

sl_zigbee_mfg_security_struct_t

sl_zigbee_duty_cycle_limits_t

sl_zigbee_per_device_duty_cycle_t

sl_nwk_packet_exchange_t

sl_zigbee_mac_filter_match_struct_t

sl_zigbee_source_route_table_entry_t

sl_zigbee_beacon_classification_params_t

sl_zigbee_token_info_t

sl_zigbee_token_data_t

aps_duplicate_msg_entry

sl_zigbee_neighbor_table_entry_info_t

sl_zigbee_broadcast_table_entry_t

sl_zigbee_pan_info_t

sl_zigbee_network_info_t

sl_zigbee_endpoint_description_t

sl_zigbee_node_descriptor_info_t

sl_zigbee_rx_packet_info_t

8

8

16

48

22

21

16

42

16

74

37

36

72

0x0000u

26

11

0

3

5

  (SL_ZIGBEE_MAX_802_15_4_CHANNEL_NUMBER - SL_ZIGBEE_MIN_802_15_4_CHANNEL_NUMBER + 1)

0x07FFF800UL

27

0x07FFFFFFUL

26

0x1FF

8

28

31

0xF8000000UL

(page, channel)

0x0000u

0xFFFFu

0

{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }

0xFFu

0xFFFFu

0xFFFEu

0xFFFDu

0xFFFCu

0xFFu

0u

0xFFu

0xF2u

0x0000u

0xFFFFu

0x7FFFu

(20 * 4)

0x1002u

0xFFu

0

0xFFFCu

0xFFFDu

0xFFFFu

0xFFFFu

0xFFF8u

0xFFF9u

(parameters)

0x0000

0x0001

0x0002

0xC00Eu

0xC00Du

0xC016u

0x0003u

0x8003u

0x0004u

0x8004u

0x0005u

0x0000

0x0000u

0x00800000UL

SL_ZIGBEE_DISTRIBUTED_TRUST_CENTER_MODE

SL_ZIGBEE_TRUST_CENTER_GLOBAL_LINK_KEY

0xCABAD11FUL

33u

2u

0u

1u

127

0xFFF8u

(address)

0xFFu

16