nRF5 SDK for Thread and Zigbee v3.2.0
Data Structures | Macros | Typedefs | Enumerations | Variables
Base typedefs
ZBOSS framework

Data Structures

union  zb_addr_u_t
 
union  zb_addr_u
 Union to address either long or short address. More...
 

Macros

#define ZB_32BIT_WORD
 
#define ZB_XDATA
 
#define ZB_CODE
 
#define ZB_IAR_CODE
 
#define ZB_REGISTER   register
 
#define ZB_VOID_ARGLIST   void
 
#define ZB_CONST   const
 
#define ZB_INLINE
 
#define ZB_BITFIELD_CAST(x)   (x)
 
#define ZB_CPP_STR2(x)   #x
 
#define ZB_CPP_STR(x)   ZB_CPP_STR2(x)
 
#define ZB_INT8_MIN   (-127 - 1)
 
#define ZB_INT8_MAX   127
 
#define ZB_UINT8_MIN   0
 
#define ZB_UINT8_MAX   255
 
#define ZB_INT16_MIN   (-32767 - 1)
 
#define ZB_INT16_MAX   32767
 
#define ZB_UINT16_MIN   0
 
#define ZB_UINT16_MAX   65535
 
#define ZB_INT32_MIN   (-2147483647L - 1)
 
#define ZB_INT32_MAX   2147483647L
 
#define ZB_UINT32_MIN   0UL
 
#define ZB_UINT32_MAX   4294967295UL
 
#define ZB_UINT_MIN   0UL
 
#define ZB_SHORT_MIN   ZB_INT32_MIN
 
#define ZB_SHORT_MAX   ZB_INT32_MAX
 
#define ZB_USHORT_MAX   ZB_UINT32_MAX
 
#define ZB_INT_MIN   ZB_INT32_MIN
 
#define ZB_INT_MAX   ZB_INT32_MAX
 
#define ZB_UINT_MAX   ZB_UINT32_MAX
 
#define ZB_INT_MASK   0x7fffffff
 
#define ZB_PACKED_STRUCT
 
#define ZB_PACKED_PRE
 
#define ZB_WEAK_PRE
 
#define ZB_WEAK
 
#define ZB_IS_64BIT_ADDR_UNKNOWN(addr)   (!ZB_MEMCMP((addr), (void const*)g_unknown_ieee_addr, 8))
 
#define ZB_64BIT_ADDR_UNKNOWN(addr)   ZB_MEMSET((addr), -1, 8)
 
#define ZB_64BIT_ADDR_CMP(one, two)   ((zb_bool_t)!ZB_MEMCMP((one), (two), 8))
 Check two long addresses are equal. More...
 
#define ZB_EXTPANID_IS_ZERO   ZB_IS_64BIT_ADDR_ZERO
 
#define ZB_EXTPANID_ZERO   ZB_64BIT_ADDR_ZERO
 
#define ZB_EXTPANID_COPY   ZB_64BIT_ADDR_COPY
 
#define ZB_EXTPANID_CMP   ZB_64BIT_ADDR_CMP
 
#define ZB_IEEE_ADDR_IS_ZERO   ZB_IS_64BIT_ADDR_ZERO
 
#define ZB_IEEE_ADDR_IS_UNKNOWN   ZB_IS_64BIT_ADDR_UNKNOWN
 
#define ZB_IEEE_ADDR_ZERO   ZB_64BIT_ADDR_ZERO
 
#define ZB_IEEE_ADDR_UNKNOWN   ZB_64BIT_ADDR_UNKNOWN
 
#define ZB_IEEE_ADDR_COPY   ZB_64BIT_ADDR_COPY
 
#define ZB_IEEE_ADDR_CMP   ZB_64BIT_ADDR_CMP
 
#define ZB_CCM_KEY_IS_ZERO(k)   (ZB_IS_64BIT_ADDR_ZERO((zb_uint8_t*)(k)) && ZB_IS_64BIT_ADDR_ZERO(((zb_uint8_t*)(k)) + 8))
 
#define ZB_ADDR_CMP(addr_mode, addr1, addr2)
 
#define ZB_INT8_C(c)   c
 
#define ZB_UINT8_C(c)   c ## U
 
#define ZB_INT16_C(c)   c
 
#define ZB_UINT16_C(c)   c ## U
 
#define ZB_INT32_C(c)   c ## L
 
#define ZB_UINT32_C(c)   c ## UL
 
#define ZB_OFFSETOF(t, f)   (zb_size_t)(&((t *)0)->f)
 
#define ZB_OFFSETOF_VAR(s, f)   (zb_size_t)(((zb_int8_t *)(&(s)->f)) - ((zb_int8_t *)(s)))
 
#define ZB_SIZEOF_FIELD(type, field)   (sizeof(((type*)0)->field))
 
#define ZB_ARRAY_SIZE(arr)   (sizeof((arr))/sizeof((arr)[0]))
 
#define ZB_SIGNED_SHIFT(v, s)   ((zb_int_t)(v) >> (s))
 
#define ZB_ASSERT_IF_NOT_ALIGNED(data_type, length)   ZB_ASSERT_COMPILE_DECL(((sizeof(data_type) % (length)) == 0));
 
#define ZB_ASSERT_IF_NOT_ALIGNED_TO_4(data_type)   ZB_ASSERT_IF_NOT_ALIGNED(data_type,4)
 
#define ZB_GET_LOW_BYTE(val)   ((val) & 0xFF)
 
#define ZB_GET_HI_BYTE(val)   (((val) >> 8) & 0xFF)
 
#define ZB_SET_LOW_BYTE(res, val)   (res) = (((res) & 0xFF00) | ((val) & 0xFF))
 
#define ZB_SET_HI_BYTE(res, val)   (res) = ((((val) << 8) & 0xFF00) | ((res) & 0xFF))
 
#define ZB_PKT_16B_ZERO_BYTE   0
 
#define ZB_PKT_16B_FIRST_BYTE   1
 
#define ZB_ASSIGN_UINT16(ptr, vp)   *((zb_uint16_t*)(ptr)) = *(zb_uint16_t*)(vp)
 
#define ZB_ASSIGN_INT16(ptr, vp)   *((zb_int16_t*)(ptr)) = *(zb_int16_t*)(vp)
 
#define ZB_COPY_UINT24(ptr, vp)   *((zb_uint24_t*)(ptr)) = *(zb_uint24_t*)(vp)
 
#define ZB_COPY_INT24(ptr, vp)   *((zb_int24_t*)(ptr)) = *(zb_int24_t*)(vp)
 
#define ZB_ASSIGN_UINT32(ptr, vp)   *((zb_uint32_t*)(ptr)) = *(zb_uint32_t*)(vp)
 
#define ZB_ASSIGN_INT32(ptr, vp)   *((zb_int32_t*)(ptr)) = *(zb_int32_t*)(vp)
 
#define ZB_ARRAY_IDX_BY_ELEM(ar, el)   ((el) - (ar))
 
#define ZB_ARRAY_IDX_BY_STRUCT_ELEM(ar, el, el_size)   ( ((zb_size_t)(el) - (zb_size_t)(ar)) / (el_size) )
 
#define MIN_SIGNED_24BIT_VAL   ((zb_int32_t)0xFF800001) /* FIXME: which value to prefer? Because 0x800000 is reserved in ZCL */
 
#define MAX_SIGNED_24BIT_VAL   ((zb_int32_t)0x7FFFFF)
 
#define MIN_SIGNED_48BIT_VAL   ((zb_int32_t)0xFFFF800000000001)
 
#define MAX_SIGNED_48BIT_VAL   ((zb_int32_t)0x7FFFFFFFFFFF)
 
#define ZB_S64_FROM_S48(x)   ((x & 0xFFFFFFFFFFFF) | ((x & 0x800000000000) ? 0xFFFF000000000000 : 0x0))
 
#define ZB_S64_TO_S48(x)   ((zb_int64_t)(x & 0xFFFFFFFFFFFF))
 
#define ZB_S32_FROM_S24(x)   ((x & 0xFFFFFF) | ((x & 0x800000) ? 0xFF000000 : 0x0))
 
#define ZB_S32_TO_S24(x)   ((zb_int32_t)(x & 0xFFFFFF))
 
#define ZB_INIT_UINT48(high_val, low_val)   (high_val)
 
#define ZB_ASSIGN_UINT48(high_val, low_val)   (high_val)
 
#define ZB_UINT48_ADD(val1, val2)   ((val1) + (val2))
 
#define ZB_UINT48_SUB(val1, val2)   ((val1) - (val2))
 
#define ZB_ASSIGN_INT24_FROM_INT32(int32_val)   (int32_val)
 
#define ZB_GET_INT32_FROM_INT24(int24_val)   (int24_val)
 
#define ZB_ASSIGN_UINT24_FROM_UINT32(uint32_val)   (uint32_val)
 
#define ZB_GET_UINT32_FROM_UINT24(uint24_val)   (uint24_val)
 
#define ZB_HTOLE24(ptr, val)   ZB_HTOLE32((ptr), (val))
 
#define ZB_HTOLE48(ptr, val)   ZB_HTOLE32((ptr), (val))
 
#define ZB_UINT48_IS_EQUAL(val1, val2)   ((val1) == (val2))
 
#define ZB_UINT48_IS_GREAT(val1, val2)   ((val1) > (val2))
 
#define ZB_UINT48_IS_LESS(val1, val2)   ((val1) < (val2))
 
#define ZB_UINT48_IS_GREAT_OR_EQUAL(val1, val2)   (!ZB_UINT48_IS_LESS(val1, val2))
 
#define ZB_UINT48_IS_LESS_OR_EQUAL(val1, val2)   (!ZB_UINT48_IS_GREAT(val1, val2))
 
#define PUT_DATA24(ptr, val)   (ZB_HTOLE24(ptr, val), (ptr) += ZB_24BIT_SIZE)
 
#define PUT_DATA24_VAL(ptr, val)
 
#define PUT_DATA48(ptr, val)   (ZB_HTOLE48(ptr, val), (ptr) += ZB_48BIT_SIZE)
 
#define PUT_DATA48_VAL(ptr, val)
 
#define ZB_UINT8_MSB_NIBBLE(X)   (((X) >> 4) & 0x0F)
 
#define ZB_UINT8_LSB_NIBBLE(X)   ((X) & 0x0F)
 
#define ZB_UINT4x2_TO_UINT8(MSB_N, LSB_N)   ((MSB_N << 4) | ZB_UINT8_LSB_NIBBLE(LSB_N))
 

Typedefs

typedef zb_uint32_t zb_lbitfield_t
 
typedef long long zb_int64_t
 
typedef unsigned long long zb_uint64_t
 
typedef zb_ushort_t zb_uindex_t
 
typedef enum zb_bool_e zb_bool_t
 General purpose boolean type. More...
 
typedef zb_uint8_t zb_64bit_data_t [8]
 
typedef union zb_addr_u_t zb_addr_u
 
typedef zb_uint64_t zb_uint48_t
 
typedef zb_int64_t zb_int48_t
 
typedef zb_int32_t zb_int24_t
 
typedef zb_uint32_t zb_uint24_t
 

Enumerations

enum  zb_bool_e { ZB_FALSE = 0, ZB_TRUE = 1 }
 General purpose boolean type. More...
 

Variables

const zb_64bit_addr_t g_zero_addr
 
const zb_64bit_addr_t g_unknown_ieee_addr
 

Endian change API.

Macros to change words endian and access words at potentially non-aligned pointers.

ZigBee uses little endian, see ZB spec, subclause 1.2.1.3.

void zb_htole16 (zb_uint8_t *ptr, zb_uint8_t *val)
 
void zb_htole32 (zb_uint8_t *ptr, zb_uint8_t *val)
 
void zb_put_next_htole16 (zb_uint8_t **dst, zb_uint16_t val)
 
void * zb_put_next_htole32 (zb_uint8_t *dst, zb_uint32_t val1)
 
void zb_get_next_letoh16 (zb_uint16_t *dst, zb_uint8_t **src)
 
void * zb_put_next_2_htole16 (zb_uint8_t *dst, zb_uint16_t val1, zb_uint16_t val2)
 
void * zb_put_next_2_htole32 (zb_uint8_t *dst, zb_uint32_t val1, zb_uint32_t val2)
 
#define ZB_8BIT_SIZE   1
 
#define ZB_16BIT_SIZE   2
 
#define ZB_24BIT_SIZE   3
 
#define ZB_32BIT_SIZE   4
 
#define ZB_48BIT_SIZE   6
 
#define ZB_64BIT_SIZE   8
 
#define ZB_HTOLE16(ptr, val)   zb_htole16((zb_uint8_t*)(ptr), (zb_uint8_t*)(val))
 
#define ZB_HTOLE16_ONPLACE(val)
 
#define ZB_HTOLE32_ONPLACE(val)   { zb_uint32_t _v = *(val); ZB_HTOLE32((val), &_v); }
 
#define ZB_HTOLE32(ptr, val)   zb_htole32((zb_uint8_t*)(ptr), (zb_uint8_t*)(val))
 
#define ZB_HTOBE32(ptr, val)   ZB_MEMCPY(ptr, val, 4)
 
#define ZB_HTOBE16(ptr, val)   (*(zb_uint16_t *)(ptr)) = *((zb_uint16_t *)(val))
 
#define ZB_HTOBE16_VAL(ptr, val)   ((zb_uint16_t *)(ptr))[0] = (val)
 
#define ZB_HTOLE64(ptr, val)   zb_memcpy8(ptr, val)
 
#define ZB_HTOLE32_VAL(ptr, val)
 
#define ZB_HTOLE16_VAL(ptr, val)
 
#define ZB_PUT_NEXT_HTOLE16(ptr, val)
 
#define ZB_PUT_NEXT_HTOLE32(ptr, val)   (ptr) = zb_put_next_htole32((ptr), (val))
 
#define ZB_LETOH64(dst, src)   zb_memcpy8((zb_uint8_t*)dst, (zb_uint8_t*)src)
 
#define ZB_LETOH16   ZB_HTOLE16
 
#define ZB_LETOH24   ZB_HTOLE24
 
#define ZB_LETOH48   ZB_HTOLE48
 
#define ZB_LETOH32   ZB_HTOLE32
 
#define ZB_BETOH16   ZB_HTOBE16
 
#define ZB_BETOH32   ZB_HTOBE32
 
#define ZB_LETOH16_ONPLACE   ZB_HTOLE16_ONPLACE
 
#define ZB_LETOH32_ONPLACE   ZB_HTOLE32_ONPLACE
 

Base types.

typedef char zb_char_t
 Project-local char type.
 
typedef unsigned char zb_uchar_t
 Project-local unsigned char type.
 
typedef unsigned char zb_uint8_t
 Project-local 1-byte unsigned int type.
 
typedef signed char zb_int8_t
 Project-local 1-byte signed int type.
 
typedef unsigned short zb_uint16_t
 Project-local 2-byte unsigned int type.
 
typedef signed short zb_int16_t
 Project-local 2-byte signed int type.
 
typedef unsigned int zb_uint32_t
 Project-local 4-byte unsigned int type.
 
typedef signed int zb_int32_t
 Project-local 4-byte signed int type.
 
typedef zb_uint32_t zb_bitfield_t
 Type to be used for unsigned bit fields inside structure.
 
typedef zb_int32_t zb_sbitfield_t
 Type to be used for signed bit fields inside structure.
 
typedef zb_uint32_t zb_size_t
 Project-local size_t type.
 
typedef int zb_short_t
 Short int (can fit into single CPU register).
 
typedef unsigned int zb_ushort_t
 Short unsigned int (can fit into single CPU register).
 
typedef int zb_int_t
 Int (at least 2 bytes).
 
typedef unsigned int zb_uint_t
 Unsigned int (at least 2 bytes).
 
typedef zb_int_t zb_long_t
 Long int (at least 4 bytes).
 
typedef zb_uint_t zb_ulong_t
 Unsigned long int (at least 4 bytes).
 
typedef void * zb_voidp_t
 Project-local "pointer to void" type.
 
typedef void zb_void_t
 Project-local void type.
 

Address types and API.

typedef zb_uint8_t zb_64bit_addr_t [8]
 8-bytes address (xpanid or long device address) base type.
 
typedef zb_64bit_addr_t zb_ieee_addr_t
 Long (64-bit) device address.
 
typedef zb_64bit_addr_t zb_ext_pan_id_t
 Long (64-bit) extended Pan Id.
 
#define ZB_IS_64BIT_ADDR_ZERO(addr)   (!ZB_MEMCMP((addr), (void const*)g_zero_addr, 8))
 Checks that long address is a zero one. More...
 
#define ZB_64BIT_ADDR_ZERO(addr)   ZB_MEMSET((addr), 0, 8)
 Clears long address. More...
 
#define ZB_64BIT_ADDR_COPY(dst, src)   ZB_MEMCPY(dst, src, sizeof(zb_64bit_addr_t))
 Copy long address. More...
 

Detailed Description

Macro Definition Documentation

#define PUT_DATA24_VAL (   ptr,
  val 
)
Value:
{ \
zb_int24_t tmp_val = (val); \
ZB_HTOLE24((ptr), &tmp_val); \
(ptr) += ZB_24BIT_SIZE; \
}
#define PUT_DATA48_VAL (   ptr,
  val 
)
Value:
{ \
zb_uint48_t tmp_val = (val); \
ZB_HTOLE48((ptr), &tmp_val); \
(ptr) += ZB_48BIT_SIZE; \
}
#define ZB_64BIT_ADDR_CMP (   one,
  two 
)    ((zb_bool_t)!ZB_MEMCMP((one), (two), 8))

Check two long addresses are equal.

Parameters
oneaddress to compare.
twoaddress to compare to.
Returns
ZB_TRUE if addresses are equal, ZB_FALSE otherwise.
#define ZB_64BIT_ADDR_COPY (   dst,
  src 
)    ZB_MEMCPY(dst, src, sizeof(zb_64bit_addr_t))

Copy long address.

Parameters
dstwhere to copy the address.
srcaddress to copy.
#define ZB_64BIT_ADDR_ZERO (   addr)    ZB_MEMSET((addr), 0, 8)

Clears long address.

Parameters
addraddress to clear.
#define ZB_ADDR_CMP (   addr_mode,
  addr1,
  addr2 
)
Value:
((addr_mode == ZB_ADDR_16BIT_DEV_OR_BROADCAST) ? \
(addr1.addr_short == addr2.addr_short) : ZB_64BIT_ADDR_CMP(addr1.addr_long, addr2.addr_long))
ZB_64BIT_ADDR_CMP
#define ZB_64BIT_ADDR_CMP(one, two)
Check two long addresses are equal.
#define ZB_CPP_STR (   x)    ZB_CPP_STR2(x)

Create a string at compile time, like 0 - "0"

#define ZB_HTOLE16_ONPLACE (   val)
Value:
{ \
zb_uint8_t *pval = (zb_uint8_t*)val; \
zb_uint8_t a = pval[0]; \
pval[0] = pval[1]; \
pval[1] = a; \
}
zb_uint8_t
unsigned char zb_uint8_t
Project-local 1-byte unsigned int type.
Definition: zb_types.h:116
#define ZB_HTOLE16_VAL (   ptr,
  val 
)
Value:
{ \
zb_uint16_t tmp_val = (val); \
ZB_HTOLE16((ptr), &tmp_val); \
}
zb_uint16_t
unsigned short zb_uint16_t
Project-local 2-byte unsigned int type.
Definition: zb_types.h:120
#define ZB_HTOLE32_VAL (   ptr,
  val 
)
Value:
{ \
zb_uint32_t tmp_val = (val); \
ZB_HTOLE32((ptr), &tmp_val); \
}
zb_uint32_t
unsigned int zb_uint32_t
Project-local 4-byte unsigned int type.
Definition: zb_types.h:144
#define ZB_IS_64BIT_ADDR_ZERO (   addr)    (!ZB_MEMCMP((addr), (void const*)g_zero_addr, 8))

Checks that long address is a zero one.

Parameters
addraddress to check.
Returns
ZB_TRUE if address is zero, ZB_FALSE otherwise.
#define ZB_LETOH16   ZB_HTOLE16

Convert 16-bits integer from the little endian to the host endian

Parameters
ptr- destination pointer. It is ok if it not aligned to 2.
val- source pointer. It is ok if it not aligned to 2.
#define ZB_PUT_NEXT_HTOLE16 (   ptr,
  val 
)
Value:
{ \
*((ptr)++) = ((val) >> 8) & 0xff; \
*((ptr)++) = (val) & 0xff; \
}

Typedef Documentation

zb_bool_t

General purpose boolean type.

Boolean type can be ZB_TRUE or ZB_FALSE.

Enumeration Type Documentation

enum zb_bool_e

General purpose boolean type.

Enumerator
ZB_FALSE 

False value literal.

ZB_TRUE 

True value literal.

Function Documentation

void zb_put_next_htole16 ( zb_uint8_t **  dst,
zb_uint16_t  val 
)

Put next 2-bute value into buffer, move pointer

To be used for headers compose.

Parameters
dst- (in/out) address os the buffer pointer As a side effect it will be incremented by 2.
val- value
Documentation feedback | Developer Zone | Subscribe | Updated