EmberZNet API for accessing and setting stack information. See Stack Information 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_STACK_INFO_H
#define SILABS_STACK_INFO_H

void emberStackStatusHandler(EmberStatus status);

EmberNetworkStatus emberNetworkState(void);

bool emberStackIsUp(void);

EmberStatus emberWriteNodeData(bool erase);

uint32_t emberMsToNextStackEvent(void);

void emberSetPowerDescriptor(uint16_t descriptor);

#ifdef DOXYGEN_SHOULD_SKIP_THIS
EmberEUI64 emberGetEui64(void);

bool emberIsLocalEui64(EmberEUI64 eui64);

EmberNodeId emberGetNodeId(void);

EmberNodeId emberRadioGetNodeId(void);

void emberSetManufacturerCode(uint16_t code);

void emberSetMaximumIncomingTransferSize(uint16_t size);

void emberSetMaximumOutgoingTransferSize(uint16_t size);

void emberSetDescriptorCapability(uint8_t capability);

#else   // Doxygen ignores the following
extern EmberEUI64 sli_802154mac_local_eui64;
#define emberGetEui64() (sli_802154mac_local_eui64)
#define emberIsLocalEui64(eui64) \
  (MEMCOMPARE((eui64), sli_802154mac_local_eui64, EUI64_SIZE) == 0)

EmberNodeId emberGetNodeId(void);
EmberNodeId emberRadioGetNodeId(void);

extern uint16_t sli_zigbee_manufacturer_code;
extern uint16_t sli_zigbee_power_descriptor;
extern uint16_t sli_zigbee_maximum_incoming_transfer_size;
extern uint16_t sli_zigbee_maximum_outgoing_transfer_size;
extern uint8_t sli_zigbee_descriptor_capability;

enum {
  EMBER_ROUTE_ERROR_NO_ROUTE_AVAILABLE    = 0x00,
  EMBER_ROUTE_ERROR_TREE_LINK_FAILURE     = 0x01,
  EMBER_ROUTE_ERROR_NON_TREE_LINK_FAILURE = 0x02,
  EMBER_ROUTE_ERROR_LOW_BATTERY_LEVEL     = 0x03,
  EMBER_ROUTE_ERROR_NO_ROUTING_CAPACITY   = 0x04,
  EMBER_ROUTE_ERROR_NO_INDIRECT_CAPACITY  = 0x05,
  EMBER_ROUTE_ERROR_INDIRECT_TRANSACTION_EXPIRY = 0x06,
  EMBER_ROUTE_ERROR_TARGET_DEVICE_UNAVAILABLE = 0x07,
  EMBER_ROUTE_ERROR_TARGET_ADDRESS_UNALLOCATED = 0x08,
  EMBER_ROUTE_ERROR_PARENT_LINK_FAILURE   = 0x09,
  EMBER_ROUTE_ERROR_VALIDATE_ROUTE        = 0x0A,
  EMBER_ROUTE_ERROR_SOURCE_ROUTE_FAILURE  = 0x0B,
  EMBER_ROUTE_ERROR_MANY_TO_ONE_ROUTE_FAILURE = 0x0C,
  EMBER_ROUTE_ERROR_ADDRESS_CONFLICT      = 0x0D,
  EMBER_ROUTE_ERROR_VERIFY_ADDRESSES      = 0x0E,
  EMBER_ROUTE_ERROR_PAN_IDENTIFIER_UPDATE = 0x0F,
  ZIGBEE_NETWORK_STATUS_NETWORK_ADDRESS_UPDATE = 0x10,
  ZIGBEE_NETWORK_STATUS_BAD_FRAME_COUNTER = 0x11,
  ZIGBEE_NETWORK_STATUS_BAD_KEY_SEQUENCE_NUMBER = 0x12,
  ZIGBEE_NETWORK_STATUS_UNKNOWN_COMMAND = 0x13
};

EmberStatus emberSetBrokenRouteErrorCode(uint8_t errorCode);

#define emberSetManufacturerCode(code) \
  (sli_zigbee_manufacturer_code = (code))
#define emberSetMaximumIncomingTransferSize(size) \
  (sli_zigbee_maximum_incoming_transfer_size = (size))
#define emberSetMaximumOutgoingTransferSize(size) \
  (sli_zigbee_maximum_outgoing_transfer_size = (size))
#define emberSetDescriptorCapability(capability) \
  (sli_zigbee_descriptor_capability = (capability))
#endif

EmberStatus emberGetNetworkParameters(EmberNetworkParameters *parameters);

EmberStatus emberGetRadioParameters(uint8_t phyIndex, EmberMultiPhyRadioParameters *parameters);

EmberStatus emberGetNodeType(EmberNodeType *resultLocation);

EmberStatus emberSetRadioChannel(uint8_t channel);

EmberStatus emberSetLogicalAndRadioChannel(uint8_t channel);

uint8_t emberGetRadioChannel(void);

EmberStatus emberSetRadioPower(int8_t power);

int8_t emberGetRadioPower(void);

void *emberGetRailHandle(void);

EmberPanId emberGetPanId(void);

EmberPanId emberRadioGetPanId(void);

EmberStatus emberSetRadioIeee802154CcaMode(uint8_t ccaMode);

void emberGetExtendedPanId(uint8_t *resultLocation);

extern const uint8_t emberStackProfileId[];

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

typedef struct {
  uint8_t endpoint;
  EmberEndpointDescription const * description;
  uint16_t const * inputClusterList;
  uint16_t const * outputClusterList;
} EmberEndpoint;

extern uint8_t emberEndpointCount;

extern EmberEndpoint emberEndpoints[];

uint8_t emberGetEndpoint(uint8_t index);

uint8_t emberGetEndpointCount(void);

bool emberGetEndpointDescription(uint8_t endpoint,
                                 EmberEndpointDescription *result);

uint16_t emberGetEndpointCluster(uint8_t endpoint,
                                 EmberClusterListId listId,
                                 uint8_t listIndex);

#ifdef DOXYGEN_SHOULD_SKIP_THIS
bool emberIsNodeIdValid(EmberNodeId nodeId);
#else
#define emberIsNodeIdValid(nodeId) ((nodeId) < EMBER_DISCOVERY_ACTIVE_NODE_ID)
#endif

EmberNodeId emberLookupNodeIdByEui64(EmberEUI64 eui64);

EmberStatus emberLookupEui64ByNodeId(EmberNodeId nodeId,
                                     EmberEUI64 eui64Return);

void emberCounterHandler(EmberCounterType type, EmberCounterInfo info);
bool emberCounterRequiresPhyIndex(EmberCounterType type);
bool emberCounterRequiresDestinationNodeId(EmberCounterType type);

void emberStackTokenChangedHandler(uint16_t tokenAddress);

bool emberRtosIdleHandler(uint32_t *idleTimeMs);

void emberRtosStackWakeupIsrHandler(void);

EmberStatus emberGetNeighbor(uint8_t index, EmberNeighborTableEntry *result);

EmberStatus emberSetRoutingShortcutThreshold(uint8_t costThresh);

uint8_t emberGetRoutingShortcutThreshold(void);

EmberStatus emberSetInitialNeighborOutgoingCost(uint8_t cost);

uint8_t emberGetInitialNeighborOutgoingCost(void);

void emberResetRejoiningNeighborsFC(bool reset);

bool emberIsResetRejoiningNeighborsFCEnabled(void);

EmberStatus emberGetNeighborFrameCounter(EmberEUI64 nodeEui64,
                                         uint32_t *returnFrameCounter);

EmberStatus emberSetNeighborFrameCounter(EmberEUI64 nodeEui64,
                                         uint32_t frameCounter);

EmberStatus emberGetRouteTableEntry(uint8_t index, EmberRouteTableEntry *result);

uint8_t emberStackProfile(void);

uint8_t emberSecurityLevel(void);


#define R21_COMPLIANCE_REVISION       21
#define R22_COMPLIANCE_REVISION       22
#define R23_COMPLIANCE_REVISION       23
#define PRE_R21_COMPLIANCE_REVISION   0

uint8_t sl_zigbee_get_stack_compliance_revision(void);

#ifdef DOXYGEN_SHOULD_SKIP_THIS
uint8_t emberTreeDepth(void);
#endif
uint8_t emberNeighborCount(void);
#ifdef DOXYGEN_SHOULD_SKIP_THIS
uint8_t emberRouteTableSize(void);

#else   // Doxgyen ignores the following
// The '+ 0' prevents anyone from accidentally assigning to these.
#define emberTreeDepth()           (sli_zigbee_tree_depth         + 0)
#define emberMaxDepth()            (sli_zigbee_max_depth          + 0)
#define emberRouteTableSize()      (sli_zigbee_route_table_size    + 0)

extern uint8_t sli_zigbee_default_security_level;
extern uint8_t sli_zigbee_max_hops;
extern uint8_t sli_zigbee_route_table_size;
extern uint8_t sli_zigbee_source_route_table_size;
extern uint8_t sli_zigbee_max_depth;                // The maximum tree depth.
extern uint8_t sli_zigbee_tree_depth;               // The current depth.
extern uint8_t sli_zigbee_end_device_configuration;

void emberSetStackProfile(uint8_t stackProfile);

void emberSetSecurityLevel(uint8_t securityLevel);
#endif

uint8_t emberNextZigbeeSequenceNumber(void);

uint8_t emberGetMaxNwkRetries(void);


EmberStatus emberSetTxPowerMode(uint16_t txPowerMode);

uint16_t emberGetTxPowerMode(void);

EmberStatus emberSetNodeId(EmberNodeId nodeId);

uint8_t emberGetPhyInterfaceCount(void);

void emberRadioNeedsCalibratingHandler(void);

void sl_mac_calibrate_current_channel(void);

//General connectivity status APIs

void emberSetLongUpTime(bool hasLongUpTime);

void emberSetHubConnectivity(bool connected);

bool emberIsUpTimeLong(void);

bool emberIsHubConnected(void);

EmberStatus emberRadioGetSchedulerPriorities(EmberMultiprotocolPriorities *priorities);

EmberStatus emberRadioSetSchedulerPriorities(const EmberMultiprotocolPriorities *priorities);

EmberStatus emberRadioSetSchedulerSliptime(uint32_t slipTime);

EmberStatus emberRadioGetSchedulerSliptime(uint32_t *slipTime);

EmberStatus emberGetBeaconClassificationParams(EmberBeaconClassificationParams* param);

EmberStatus emberSetBeaconClassificationParams(EmberBeaconClassificationParams* param);

EmberStatus slx_zigbee_routing_set_route_record_policy(sl_zigbee_route_record_policy_type_t policy);

uint8_t slx_zigbee_routing_get_route_record_policy(void);

uint8_t emberGetTokenCount(void);

EmberStatus emberGetTokenInfo(uint8_t index,
                              EmberTokenInfo *tokenInfo);
EmberStatus emberGetTokenData(uint32_t token,
                              uint32_t index,
                              EmberTokenData *tokenData);
EmberStatus emberSetTokenData(uint32_t token,
                              uint32_t index,
                              EmberTokenData *tokenData);

void emberUpdateMultiMacRejoinChannelMaskForSelectionOrJoiningDevice(uint32_t *rejoinChannelMask);

void sl_zigbee_token_factory_reset(bool exclude_outgoing_fc, bool exclude_boot_counter);

#endif // SILABS_STACK_INFO_H

Modules#

EmberEndpointDescription

EmberEndpoint