License#

Copyright 2018 Silicon Laboratories Inc. www.silabs.com

SPDX-License-Identifier: Zlib

The licensor of this software is Silicon Laboratories Inc.

This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.

Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

/***************************************************************************/
#ifndef __EMBER_TYPES_H__
#define __EMBER_TYPES_H__

#ifdef EMBER_TEST
#include PLATFORM_HEADER
#endif
#include "sl_common.h"

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>

#ifndef DOXYGEN_SHOULD_SKIP_THIS
#include "stack/config/ember-configuration-defaults.h"
#endif //DOXYGEN_SHOULD_SKIP_THIS

#define EXTENDED_PAN_ID_SIZE 8

#define EUI64_SIZE 8

#define EMBER_ENCRYPTION_KEY_SIZE 16

typedef uint8_t EmberEUI64[EUI64_SIZE];

typedef uint16_t EmberNodeId;

typedef uint16_t EmberPanId;

#define EMBER_NULL_NODE_ID                0xFFFFu

#define EMBER_BROADCAST_ADDRESS           0xFFFF

#define EMBER_USE_LONG_ADDRESS            0xFFFE

#define EMBER_COORDINATOR_ADDRESS         0x0000

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberNodeType
#else
typedef uint8_t EmberNodeType;
enum
#endif
{
  EMBER_UNKNOWN_DEVICE = 0,
  EMBER_STAR_COORDINATOR = 1,
  EMBER_STAR_RANGE_EXTENDER = 2,
  EMBER_STAR_END_DEVICE = 3,
  EMBER_STAR_SLEEPY_END_DEVICE = 4,
  EMBER_DIRECT_DEVICE = 5,
  EMBER_MAC_MODE_DEVICE = 6,
  EMBER_MAC_MODE_SLEEPY_DEVICE = 7,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberNetworkStatus
#else
typedef uint8_t EmberNetworkStatus;
enum
#endif
{
  EMBER_NO_NETWORK,
  EMBER_JOINING_NETWORK,
  EMBER_JOINED_NETWORK,
  EMBER_RADIO_TEST
};

typedef struct {
  uint16_t  panId;
  int16_t   radioTxPower;
  uint16_t   radioChannel;
} EmberNetworkParameters;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberChildFlags
#else
typedef uint8_t EmberChildFlags;
enum
#endif
{
  EMBER_CHILD_FLAGS_DEVICE_IS_RANGE_EXTENDER_BIT       = 0x02,
  EMBER_CHILD_FLAGS_DEVICE_IS_SLEEPY_BIT               = 0x04,
  EMBER_CHILD_FLAGS_HAVE_PENDING_DATA_BIT              = 0x08,
  EMBER_CHILD_FLAGS_AES_SECURITY_CAPABLE_BIT           = 0x10,
  EMBER_CHILD_FLAG_DEVICE_IS_EXTENDED_BIT              = 0x20,
};

typedef uint16_t EmberMessageLength;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberMessageOptions
#else
typedef uint8_t EmberMessageOptions;
enum
#endif
{
  EMBER_OPTIONS_NONE                     = 0x00,
  EMBER_OPTIONS_SECURITY_ENABLED         = 0x01,
  EMBER_OPTIONS_ACK_REQUESTED            = 0x02,
  EMBER_OPTIONS_HIGH_PRIORITY            = 0x04,
  EMBER_OPTIONS_INDIRECT                 = 0x08,
};

typedef struct {
  EmberMessageOptions options;
  EmberNodeId source;
  uint8_t endpoint;
  int8_t rssi;
  EmberMessageLength length;
  uint8_t *payload;
  uint32_t timestamp;
  uint8_t lqi;
} EmberIncomingMessage;

typedef struct {
  EmberMessageOptions options;
  EmberNodeId destination;
  uint8_t endpoint;
  uint8_t tag;
  EmberMessageLength length;
  uint8_t *payload;
  int8_t ackRssi;
  uint32_t timestamp;
} EmberOutgoingMessage;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberMacAddressMode
#else
typedef uint8_t EmberMacAddressMode;
enum
#endif
{
  EMBER_MAC_ADDRESS_MODE_NONE  = 0x00,
  EMBER_MAC_ADDRESS_MODE_SHORT = 0x02,
  EMBER_MAC_ADDRESS_MODE_LONG  = 0x03,
};

typedef struct {
  union {
    uint8_t longAddress[EUI64_SIZE];
    uint16_t shortAddress;
  } addr;

  EmberMacAddressMode mode; 
} EmberMacAddress;

typedef struct {
  EmberMacAddress srcAddress;
  EmberMacAddress dstAddress;
  EmberPanId srcPanId;
  EmberPanId dstPanId;
  bool srcPanIdSpecified;
  bool dstPanIdSpecified;
} EmberMacFrame;

typedef struct {
  EmberMessageOptions options;
  EmberMacFrame macFrame;
  int8_t rssi;
  uint8_t lqi;
  uint32_t frameCounter;
  EmberMessageLength length;
  uint8_t *payload;
  uint32_t timestamp;
} EmberIncomingMacMessage;

typedef struct {
  EmberMessageOptions options;
  EmberMacFrame macFrame;
  uint8_t tag;
  uint32_t frameCounter;
  EmberMessageLength length;
  uint8_t *payload;
  int8_t ackRssi;
  uint32_t timestamp;
} EmberOutgoingMacMessage;

typedef struct {
  uint8_t contents[EMBER_ENCRYPTION_KEY_SIZE];
} EmberKeyData;

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

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberEventUnits
#else
typedef uint8_t EmberEventUnits;
enum
#endif
{
  EMBER_EVENT_INACTIVE = 0,
  EMBER_EVENT_MS_TIME,
  EMBER_EVENT_QS_TIME,
  EMBER_EVENT_MINUTE_TIME,
  EMBER_EVENT_ZERO_DELAY
};

typedef uint8_t EmberTaskId;

typedef struct sl_connect_radio_priority {
  uint8_t rx;
  uint8_t starting_tx;
  uint8_t tx_step;
} sl_connect_radio_priority_t;

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

// Forward declarations to make up for C's one-pass type checking.
struct Event_s;
struct EventQueue_s;

typedef const struct {
  struct EventQueue_s *queue;           // the queue this event goes on
  void (*handler)(struct Event_s *);    // called when the event fires
  void (*marker)(struct Event_s *);     // marking function, can be NULL
  const char *name;                     // event name for debugging purposes
} EventActions;

typedef struct Event_s {
  EventActions *actions;                // static data

  // For internal use only, but the 'next' field must be initialized
  // to NULL.
  struct Event_s *next;
  uint32_t timeToExecute;
} Event;

typedef struct EventQueue_s {
  Event *isrEvents;
  Event *events;
} EventQueue;

typedef struct {
  EmberEventUnits status;
  EmberTaskId taskid;
  uint32_t timeToExecute;
} EmberEventControl;

typedef const struct EmberEventData_S {
  EmberEventControl *control;
  void (*handler)(void);
} EmberEventData;

typedef struct {
  uint32_t nextEventTime;
  EmberEventData *events;
  bool busy;
} EmberTaskControl;

enum {
  EMBER_OUTGOING_MESSAGES = 0x0001,
  EMBER_INCOMING_MESSAGES = 0x0002,
  EMBER_RADIO_IS_ON = 0x0004,
  EMBER_ASSOCIATING = 0x0008,
  EMBER_SCANNING = 0x0010,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberCounterType
#else
typedef uint8_t EmberCounterType;
enum
#endif
{
  EMBER_COUNTER_PHY_IN_PACKETS,

  EMBER_COUNTER_PHY_OUT_PACKETS,

  EMBER_COUNTER_MAC_IN_UNICAST,

  EMBER_COUNTER_MAC_IN_BROADCAST,

  EMBER_COUNTER_MAC_OUT_UNICAST_NO_ACK,

  EMBER_COUNTER_MAC_OUT_UNICAST_ACK_SUCCESS,

  EMBER_COUNTER_MAC_OUT_UNICAST_ACK_FAIL,

  EMBER_COUNTER_MAC_OUT_UNICAST_CCA_FAIL,

  EMBER_COUNTER_MAC_OUT_UNICAST_RETRY,

  EMBER_COUNTER_MAC_OUT_BROADCAST,

  EMBER_COUNTER_MAC_OUT_BROADCAST_CCA_FAIL,

  EMBER_COUNTER_MAC_OUT_ENCRYPT_FAIL,

  EMBER_COUNTER_MAC_DROP_IN_MEMORY,

  EMBER_COUNTER_MAC_DROP_IN_FRAME_COUNTER,

  EMBER_COUNTER_MAC_DROP_IN_DECRYPT,

  EMBER_COUNTER_NWK_OUT_FORWARDING,

  EMBER_COUNTER_NWK_IN_SUCCESS,

  EMBER_COUNTER_NWK_DROP_IN_WRONG_SOURCE,

  EMBER_COUNTER_NWK_DROP_IN_FORWARDING,

  EMBER_COUNTER_UART_IN_DATA,
  EMBER_COUNTER_UART_IN_MANAGEMENT,
  EMBER_COUNTER_UART_IN_FAIL,
  EMBER_COUNTER_UART_OUT_DATA,
  EMBER_COUNTER_UART_OUT_MANAGEMENT,
  EMBER_COUNTER_UART_OUT_FAIL,

  // Counters for non-packet events below.
  EMBER_COUNTER_ROUTE_2_HOP_LOOP,
  EMBER_COUNTER_BUFFER_ALLOCATION_FAIL,

  EMBER_ASH_V3_ACK_SENT,
  EMBER_ASH_V3_ACK_RECEIVED,
  EMBER_ASH_V3_NACK_SENT,
  EMBER_ASH_V3_NACK_RECEIVED,
  EMBER_ASH_V3_RESEND,
  EMBER_ASH_V3_BYTES_SENT,
  EMBER_ASH_V3_TOTAL_BYTES_RECEIVED,
  EMBER_ASH_V3_VALID_BYTES_RECEIVED,
  EMBER_ASH_V3_PAYLOAD_BYTES_SENT,

  EMBER_COUNTER_TYPE_COUNT,
};

typedef uint16_t EmberBuffer;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberPhyType
#else
typedef uint8_t EmberPhyType;
enum
#endif
{
  EMBER_RADIO_CONFIGURATOR,

  EMBER_STANDARD_PHY_2_4GHZ,

  EMBER_STANDARD_PHY_915MHZ,

  EMBER_STANDARD_PHY_863MHZ
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberCalType
#else
typedef uint32_t EmberCalType;
enum
#endif
{
  EMBER_CAL_TEMP_VCO = 0x00000001,

  EMBER_CAL_IRCAL    = 0x00010000,

  EMBER_CAL_ALL      = 0x00010001
};

#define EMBER_CAL_INVALID_VALUE    (0xFFFFFFFF)

#ifndef DOXYGEN_SHOULD_SKIP_THIS
//doxygen should see this in error-def.h

#ifndef __EMBERSTATUS_TYPE__
#define __EMBERSTATUS_TYPE__
typedef uint8_t EmberStatus;
#endif //__EMBERSTATUS_TYPE__

#endif //DOXYGEN_SHOULD_SKIP_THIS

//------------------------------------------------------------------------------
// INTERNAL TYPES AND DEFINES
//------------------------------------------------------------------------------

#ifndef DOXYGEN_SHOULD_SKIP_THIS

typedef struct {
  EmberNodeId destination;
  uint8_t endpoint;
  uint8_t tag;
  EmberBuffer payload;
  EmberMessageOptions txOptions;
} EmOutgoingPacket;

typedef struct {
  uint32_t lastSeen;
  uint32_t frameCounter;
  EmberNodeId shortId;
  EmberEUI64 longId;
  uint8_t flags;
  uint8_t leaveCount;
} EmberChildEntry;

typedef uint8_t EmberLibraryStatus;

typedef void (*ClientResyncCallback)(EmberStatus status);

typedef struct {
  EmberBuffer* buffer_addr;
  uint16_t buffer_length;
} EmberBufferDesc;

// A library's status is an 8-bit value with information about it.
// The high bit indicates whether the library is present (1), or if it is a
// stub (0).  The lower 7-bits can be used for codes specific to the library.
// This allows a library, like the security library, to specify what additional
// features are present.
// A value of 0xFF is reserved, it indicates an error in retrieving the
// library status.
#define EMBER_LIBRARY_PRESENT_MASK          0x80
#define EMBER_LIBRARY_IS_STUB               0x00
#define EMBER_LIBRARY_ERROR                 0xFF

#define emberDebugPrintf(...)
#define emLog(type, ...)
#define emLogLine(type, ...)
#define emLogBytes(type, format, bytes, count, ...)

#endif //DOXYGEN_SHOULD_SKIP_THIS

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum EmberTxStreamParameters
#else
typedef uint8_t EmberTxStreamParameters;
enum
#endif
{
  TX_STREAM_PN9, 
  TX_STREAM_CW   
};

#endif // __EMBER_TYPES_H__

Modules#

EmberNetworkParameters

EmberIncomingMessage

EmberOutgoingMessage

EmberMacAddress

EmberMacFrame

EmberIncomingMacMessage

EmberOutgoingMacMessage

EmberKeyData

sl_connect_radio_priority

EventActions

Event_s

EventQueue_s

EmberEventControl

EmberEventData_S

EmberTaskControl

8

8

16

0xFFFFu

0xFFFF

0xFFFE

0x0000

(0xFFFFFFFF)