Modules#

EmberGpAddress

EmberGpSinkAddress

EmberGpSinkGroup

EmberGpSinkListEntry

EmberGpProxyTableEntry

EmberGpSinkTableEntry

EmberCGpAddress

EmberGpProxyClusterAttributes

EmberGpTxQueueEntry

EmberGpApplicationInfo

EmberGpAttributeRecord

EmberGpDataPointDescriptor

EmberGpReportDescriptor

EmberGpSwitchInformation

EmberGpGenericSwitchData

EmberGpTranslationTableAdditionalInfoBlockOptionRecordField

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

// Mask used in the Gp Ep Incoming Message Handler to pass bidirectional information
// Incoming GPDF has rxAfterTx bit set
#define EMBER_GP_BIDIRECTION_INFO_RX_AFTER_TX_MASK        0x01
// A tx queue is available at gp stub to hold an outgoing GPDF
#define EMBER_GP_BIDIRECTION_INFO_TX_QUEUE_AVAILABLE_MASK 0x02
typedef uint32_t EmberGpSourceId;
typedef uint32_t EmberGpSecurityFrameCounter;
typedef uint32_t EmberGpMic;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberGpSecurityLevel
#else
typedef uint8_t EmberGpSecurityLevel;
enum
#endif
{
  EMBER_GP_SECURITY_LEVEL_NONE = 0x00,
  EMBER_GP_SECURITY_LEVEL_RESERVED = 0x01,
  EMBER_GP_SECURITY_LEVEL_FC_MIC = 0x02,
  EMBER_GP_SECURITY_LEVEL_FC_MIC_ENCRYPTED = 0x03,
};
#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberGpKeyType
#else
typedef uint8_t EmberGpKeyType;
enum
#endif
{
  EMBER_GP_SECURITY_KEY_NONE = 0x00,
  EMBER_GP_SECURITY_KEY_NWK = 0x01,
  EMBER_GP_SECURITY_KEY_GPD_GROUP = 0x02,
  EMBER_GP_SECURITY_KEY_NWK_DERIVED = 0x03,
  EMBER_GP_SECURITY_KEY_GPD_OOB = 0x04,
  EMBER_GP_SECURITY_KEY_GPD_DERIVED = 0x07,
};
#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberGpApplicationId
#else
typedef uint8_t EmberGpApplicationId;
enum
#endif
{
  EMBER_GP_APPLICATION_SOURCE_ID = 0x00,
  EMBER_GP_APPLICATION_IEEE_ADDRESS = 0x02,
};

#define EMBER_GP_APPLICATION_ID_MASK 0x03
#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberGpProxyTableEntryStatus
#else
typedef uint8_t EmberGpProxyTableEntryStatus;
enum
#endif
{
  EMBER_GP_PROXY_TABLE_ENTRY_STATUS_ACTIVE = 0x01,
  EMBER_GP_PROXY_TABLE_ENTRY_STATUS_UNUSED = 0xFF,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberGpSinkTableEntryStatus
#else
typedef uint8_t EmberGpSinkTableEntryStatus;
enum
#endif
{
  EMBER_GP_SINK_TABLE_ENTRY_STATUS_ACTIVE = 0x01,
  EMBER_GP_SINK_TABLE_ENTRY_STATUS_UNUSED = 0xFF,
};

typedef struct {
  union {
    EmberEUI64 gpdIeeeAddress;
    EmberGpSourceId sourceId;
  } id;
  EmberGpApplicationId applicationId;
  uint8_t endpoint;
} EmberGpAddress;

typedef enum {
  EMBER_GP_SINK_TYPE_FULL_UNICAST,
  EMBER_GP_SINK_TYPE_D_GROUPCAST,
  EMBER_GP_SINK_TYPE_GROUPCAST,
  EMBER_GP_SINK_TYPE_LW_UNICAST,
  EMBER_GP_SINK_TYPE_UNUSED = 0xFF
} EmberGpSinkType;

typedef struct {
  EmberEUI64 sinkEUI;
  EmberNodeId sinkNodeId;
} EmberGpSinkAddress;

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

typedef struct {
  EmberGpSinkType type;

  union {
    EmberGpSinkAddress unicast;
    EmberGpSinkGroup groupcast;
    EmberGpSinkGroup groupList;   // Entry for Sink Group List
  } target;
} EmberGpSinkListEntry;

#define GP_SINK_LIST_ENTRIES 2

// The size of the SinkList entries in sink table in format of octet string that has a format of {<1 byte length>, <n bytes for sink groups>}
#define GP_SIZE_OF_SINK_LIST_ENTRIES_OCTET_STRING (1 + (GP_SINK_LIST_ENTRIES * (sizeof(EmberGpSinkGroup))))

typedef struct {
  EmberGpProxyTableEntryStatus status;
  uint32_t options;
  EmberGpAddress gpd;
  EmberNodeId assignedAlias;
  uint8_t securityOptions;
  EmberGpSecurityFrameCounter gpdSecurityFrameCounter;
  EmberKeyData gpdKey;
  EmberGpSinkListEntry sinkList[GP_SINK_LIST_ENTRIES];
  uint8_t groupcastRadius;
  uint8_t searchCounter;
} EmberGpProxyTableEntry;

typedef struct {
  EmberGpSinkTableEntryStatus status;
  uint16_t options;
  EmberGpAddress gpd;
  uint8_t deviceId;
  EmberGpSinkListEntry sinkList[GP_SINK_LIST_ENTRIES];
  EmberNodeId assignedAlias;
  uint8_t groupcastRadius;
  uint8_t securityOptions;
  EmberGpSecurityFrameCounter gpdSecurityFrameCounter;
  EmberKeyData gpdKey;
} EmberGpSinkTableEntry;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberCGpTxOption
#else
typedef uint8_t EmberCGpTxOption;
enum
#endif
{
  EMBER_CGP_TX_OPTION_NONE = 0x00,
  EMBER_CGP_TX_OPTION_USE_CSMA_CA = 0x01,
  EMBER_CGP_TX_OPTION_USE_MAC_ACK = 0x02,
  EMBER_CGP_TX_OPTION_RESERVED = 0xFC,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberCGpAddressMode
#else
typedef uint8_t EmberCGpAddressMode;
enum
#endif
{
  EMBER_CGP_ADDRESS_MODE_NONE = 0x00,
  EMBER_CGP_ADDRESS_MODE_RESERVED = 0x01,
  EMBER_CGP_ADDRESS_MODE_SHORT = 0x02,
  EMBER_CGP_ADDRESS_MODE_EXTENDED = 0x03,
};

typedef struct {
  union {
    EmberNodeId shortId;
    EmberEUI64 extendedId;
  } address;
  EmberPanId panId;
  EmberCGpAddressMode mode;
} EmberCGpAddress;
#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberDGpTxOption
#else
typedef uint8_t EmberDGpTxOption;
enum
#endif
{
  EMBER_DGP_TX_OPTION_NONE = 0x00,
  EMBER_DGP_TX_OPTION_USE_GP_TX_QUEUE = 0x01,
  EMBER_DGP_TX_OPTION_USE_CSMA_CA = 0x02,
  EMBER_DGP_TX_OPTION_USE_MAC_ACK = 0x04,
  EMBER_DGP_TX_OPTION_FRAME_TYPE_DATA = 0x00,
  EMBER_DGP_TX_OPTION_FRAME_TYPE_MAINTENANCE = 0x08,
  EMBER_DGP_TX_OPTION_RESERVED = 0xE0,
};

typedef struct {
  uint8_t foo;
} EmberGpProxyClusterAttributes;

typedef struct {
  bool inUse;
  bool useCca;
  EmberGpAddress addr;
  uint8_t gpdCommandId;
  EmberMessageBuffer asdu;
  uint8_t gpepHandle;
  uint16_t queueEntryLifetimeMs;
} EmberGpTxQueueEntry;

#define GP_PARAMS                         \
  EmberStatus status,                     \
  uint8_t gpdLink,                        \
  uint8_t sequenceNumber,                 \
  EmberGpAddress * addr,                  \
  EmberGpSecurityLevel gpdfSecurityLevel, \
  EmberGpKeyType 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))

//3 consumed by device id, options, and app info byte
#define GP_COMMISSIONING_MAX_BYTES (55 - 3)

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];
} EmberGpApplicationInfo;

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;
} EmberGpAttributeRecord;
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;
  EmberGpAttributeRecord attrRecord;
} EmberGpDataPointDescriptor;

typedef struct {
  uint8_t               repId;
  uint8_t               reportOptions;
  uint16_t              timeoutPeriod;
  uint8_t               totalLength;
  EmberGpDataPointDescriptor  dataPoint;
} EmberGpReportDescriptor;
typedef struct {
  uint8_t switchInfoLength;
  uint8_t nbOfContacts;
  uint8_t switchType;
  uint8_t currentContact;
  uint8_t savedContact;
}EmberGpSwitchInformation;
#define TT_NB_MAX_OPTION_RECORD                                         (8)
typedef struct {
  uint8_t       currentStatus;
  uint8_t       contactBitmask;
} EmberGpGenericSwitchData;

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;//EmberGpTranslationTableAdditionalInfoBlockOptionRecordOptionDataField;
} EmberGpTranslationTableAdditionalInfoBlockOptionRecordField;


#define GP_GPD_SRC_ID_FOR_CAHNNEL_CONFIG 0x00000000
#define GP_GPD_SRC_ID_WILDCARD           0xFFFFFFFF

// GPD SrcID reserved values
#define GP_GPD_SRC_ID_RESERVED_0 0x00000000
#define GP_GPD_SRC_ID_RESERVED_FFFFFF9 0xFFFFFFF9
#define GP_GPD_SRC_ID_RESERVED_FFFFFFA 0xFFFFFFFA
#define GP_GPD_SRC_ID_RESERVED_FFFFFFB 0xFFFFFFFB
#define GP_GPD_SRC_ID_RESERVED_FFFFFFC 0xFFFFFFFC
#define GP_GPD_SRC_ID_RESERVED_FFFFFFD 0xFFFFFFFD
#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

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

EmberStatus emberDGpSend(bool action,
                         bool useCca,
                         EmberGpAddress *addr,
                         uint8_t gpdCommandId,
                         uint8_t gpdAsduLength,
                         uint8_t const *gpdAsdu,
                         uint8_t gpepHandle,
                         uint16_t gpTxQueueEntryLifetimeMs);

bool emberGpProxyTableProcessGpPairing(uint32_t options,
                                       EmberGpAddress* addr,
                                       uint8_t commMode,
                                       uint16_t sinkNwkAddress,
                                       uint16_t sinkGroupId,
                                       uint16_t assignedAlias,
                                       uint8_t* sinkIeeeAddress,
                                       EmberKeyData *gpdKey,
                                       uint32_t gpdSecurityFrameCounter,
                                       uint8_t forwardingRadius);
uint8_t emberGpProxyTableLookup(EmberGpAddress *addr);

EmberStatus emberGpProxyTableGetEntry(uint8_t proxyIndex,
                                      EmberGpProxyTableEntry *entry);

EmberStatus emberGpSinkTableGetEntry(uint8_t sinkIndex,
                                     EmberGpSinkTableEntry *entry);
uint8_t emberGpSinkTableLookup(EmberGpAddress *addr);

void emberGpSinkTableClearAll(void);

EmberStatus emberGpSinkTableSetEntry(uint8_t sinkTableIndex,
                                     EmberGpSinkTableEntry *entry);

uint8_t emberGpSinkTableFindOrAllocateEntry(EmberGpAddress *addr);

void emberGpSinkTableRemoveEntry(uint8_t index);

void emberGpSinkTableInit(void);

void emberGpSinkTableSetSecurityFrameCounter(uint8_t index,
                                             uint32_t sfc);
// Tx Queue APIs

MessageBufferQueue * emberGpGetTxQueueHead(void);

void emberGpSetMaxTxQueueEntry(uint16_t maxEntries);

uint16_t emberGetGpMaxTxQListCount(void);

uint16_t emberGetGpTxQListCount(void);

EmberMessageBuffer emberGpGetTxQueueEntryFromQueue(EmberGpTxQueueEntry *txQueue,
                                                   uint8_t *data,
                                                   uint16_t *dataLength,
                                                   uint16_t allocatedDataLength);
EmberMessageBuffer emberGpAddGpTxQueueEntryWithPayload(EmberGpTxQueueEntry *txQueue,
                                                       uint8_t *data,
                                                       uint16_t dataLength);
bool emberGpRemoveFromTxQueue(EmberGpTxQueueEntry *txQueue);

void emberGpClearTxQueue(void);

#endif // SILABS_GP_TYPES_H
 // end of name API

0x03

2

(1 + (GP_SINK_LIST_ENTRIES * (sizeof(EmberGpSinkGroup))))

(BIT(10))

(55 - 3)

(8)

0x00000000

0xFFFFFFFF

0x00000000

0xFFFFFFF9

0xFFFFFFFA

0xFFFFFFFB

0xFFFFFFFC

0xFFFFFFFD

0xFFFFFFFE

0xffff

32

5

100

0x01

0x02