zcl_types.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2012 Digi International Inc.,
 * All rights not expressly granted are reserved.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Digi International Inc. 11001 Bren Road East, Minnetonka, MN 55343
 * =======================================================================
 */

#ifndef __ZIGBEE_ZCL_TYPES_H
#define __ZIGBEE_ZCL_TYPES_H

#include "xbee/platform.h"
#include "xbee/byteorder.h"

XBEE_BEGIN_DECLS

#define ZCL_TYPE_NO_DATA            0x00     // 0 octets


#define ZCL_TYPE_GENERAL_8BIT       0x08     // 1 octet
#define ZCL_TYPE_GENERAL_16BIT      0x09     // 2 octets
#define ZCL_TYPE_GENERAL_24BIT      0x0a     // 3 octets
#define ZCL_TYPE_GENERAL_32BIT      0x0b     // 4 octets
#define ZCL_TYPE_GENERAL_40BIT      0x0c     // 5 octets
#define ZCL_TYPE_GENERAL_48BIT      0x0d     // 6 octets
#define ZCL_TYPE_GENERAL_56BIT      0x0e     // 7 octets
#define ZCL_TYPE_GENERAL_64BIT      0x0f     // 8 octets

#define ZCL_TYPE_LOGICAL_BOOLEAN    0x10     // 1 octet, invalid=0xff

#define ZCL_BOOL_FALSE     0x00
#define ZCL_BOOL_TRUE      0x01
#define ZCL_BOOL_INVALID   0xff

#define ZCL_TYPE_BITMAP_8BIT        0x18     // 1 octet
#define ZCL_TYPE_BITMAP_16BIT       0x19     // 2 octets
#define ZCL_TYPE_BITMAP_24BIT       0x1a     // 3 octets
#define ZCL_TYPE_BITMAP_32BIT       0x1b     // 4 octets
#define ZCL_TYPE_BITMAP_40BIT       0x1c     // 5 octets
#define ZCL_TYPE_BITMAP_48BIT       0x1d     // 6 octets
#define ZCL_TYPE_BITMAP_56BIT       0x1e     // 7 octets
#define ZCL_TYPE_BITMAP_64BIT       0x1f     // 8 octets

#define ZCL_TYPE_UNSIGNED_8BIT      0x20     // 1 octet, invalid=0xff
#define ZCL_TYPE_UNSIGNED_16BIT     0x21     // 2 octets, invalid = 0xffff
#define ZCL_TYPE_UNSIGNED_24BIT     0x22     // 3 octets, invalid = 0xffffff
#define ZCL_TYPE_UNSIGNED_32BIT     0x23     // 4 octets, invalid = 0xffffffff
#define ZCL_TYPE_UNSIGNED_40BIT     0x24     // 5 octets, invalid = all ff's
#define ZCL_TYPE_UNSIGNED_48BIT     0x25     // 6 octets, invalid = all ff's
#define ZCL_TYPE_UNSIGNED_56BIT     0x26     // 7 octets, invalid = all ff's
#define ZCL_TYPE_UNSIGNED_64BIT     0x27     // 8 octets, invalid = all ff's

#define ZCL_TYPE_SIGNED_8BIT        0x28     // 1 octet, invalid=0x80
#define ZCL_TYPE_SIGNED_16BIT       0x29     // 2 octets, invalid=0x8000
#define ZCL_TYPE_SIGNED_24BIT       0x2a     // 3 octets, invalid=0x800000
#define ZCL_TYPE_SIGNED_32BIT       0x2b     // 4 octets, invalid=0x80000000
#define ZCL_TYPE_SIGNED_40BIT       0x2c     // 5 octets, invalid=0x8000000000
#define ZCL_TYPE_SIGNED_48BIT       0x2d     // 6 octets, invalid=0x80...0
#define ZCL_TYPE_SIGNED_56BIT       0x2e     // 7 octets, invalid=0x80...0
#define ZCL_TYPE_SIGNED_64BIT       0x2f     // 8 octets, invalid=0x80...0

#define ZCL_TYPE_ENUM_8BIT          0x30     // 1 octet, invalid=0xff
#define ZCL_TYPE_ENUM_16BIT         0x31     // 2 octets, invalid=0xffff

#define ZCL_TYPE_FLOAT_SEMI         0x38     // 2 octets, invalid=NaN

#define ZCL_TYPE_FLOAT_SINGLE       0x39     // 4 octets, invalid=NaN

#define ZCL_TYPE_FLOAT_DOUBLE       0x3a     // 8 octets, invalid=NaN

/* For now, comment out all floating point macros.
   Needs significant work if we're going to use it.
   Decide on whether the _EXPONENT macro should be the actual signed exponent,
   or the value of the bits.

   Single precision and double-precision should map just fine to 'float' and
   'double' on platforms that properly support IEEE 754 floating point.

/ ** @name Semi-Precision Floating Point
   Macros for working with host-byte-order semi-precision floating-point values,
   stored in a uint16_t.

   @internal

   @WARNING The current driver does not implement floating point values,
            these macros are completely untested.
   @{
* /
#define ZCL_FLOAT_SEMI_IS_NEGATIVE(f)  ((uint16_t)(f) & UINT16_C(0x8000))
#define ZCL_FLOAT_SEMI_EXPONENT(f)     \
                        (((int16_t)(f) >> 10 & UINT16_C(0x001F)) - 15)
#define ZCL_FLOAT_SEMI_MANTISSA(f)     ((int16_t)(f) & UINT16_C(0x03FF))

#define ZCL_FLOAT_SEMI_IS_NAN(f)       (ZCL_FLOAT_SEMI_EXPONENT(f) == 16) && \
                                       (ZCL_FLOAT_SEMI_MANTISSA(f))

#define ZCL_FLOAT_SEMI_NORMALISED(f)   (ZCL_FLOAT_SEMI_EXPONENT(f) == -15)

#define ZCL_FLOAT_SEMI_INF_POS         UINT16_C(0x7C00)
#define ZCL_FLOAT_SEMI_INF_NEG         UINT16_C(0xFC00)

#define ZCL_FLOAT_SEMI_ZERO_POS        UINT16_C(0x0000)
#define ZCL_FLOAT_SEMI_ZERO_NEG        UINT16_C(0x8000)

/ ** @name Semi-Precision Floating Point
   Macros for working with single-precision IEEE 754 floating-point values, stored
   in a uint32_t.

   @internal

   @WARNING The current driver does not implement floating point values,
            these macros are completely untested.
   @{
* /
#define ZCL_FLOAT_IS_NEGATIVE(f)    ((uint32_t)(f) & UINT32_C(0x80000000))
#define ZCL_FLOAT_EXPONENT(f)       \
                           (((int32_t)(f) >> 23 & UINT32_C(0x00FF)) - 127)
#define ZCL_FLOAT_MANTISSA(f)       ((uint32_t)(f) & UINT32_C(0x007FFFFF))

// Not a Number (NaN) used for undefined values and is indicated by an exponent
// of all-ones with a non-zero mantissa.
#define ZCL_FLOAT_IS_NAN(f)         (ZCL_FLOAT_EXPONENT(f) == 128) && \
                                    (ZCL_FLOAT_MANTISSA(f))

// Un-normalised numbers: numbers < 2^-14 are indicated by a value of 0 for the
// exponent.
#define ZCL_FLOAT_NORMALISED(f)     (ZCL_FLOAT_EXPONENT(f) == -127)

// Infinity: indicated by an exponent of 31 and a zero mantissa
#define ZCL_FLOAT_INF_POS           (float) 0x7F800000ul
#define ZCL_FLOAT_INF_NEG           (float) 0xFF800000ul

// Zero: indicated by a zero exponent and zero mantissa
#define ZCL_FLOAT_ZERO_POS          (float) 0x00000000ul
#define ZCL_FLOAT_ZERO_NEG          (float) 0x80000000ul

*/


//
#define ZCL_TYPE_STRING_OCTET       0x41

#define ZCL_TYPE_STRING_CHAR        0x42

#define ZCL_TYPE_STRING_LONG_OCTET  0x43

#define ZCL_TYPE_STRING_LONG_CHAR   0x44

// Array, Structure, Set, Bag
// These datatypes are currently unsupported.

#define ZCL_TYPE_ARRAY              0x48     // invalid=0xffff in first 2 octets
#define ZCL_TYPE_STRUCT             0x4C     // invalid=0xffff in first 2 octets

#define ZCL_TYPE_SET                0x50     // number of elements = 0xffff
#define ZCL_TYPE_BAG                0x51     // number of elements = 0xffff

#define ZCL_TYPE_TIME_TIMEOFDAY     0xE0     // 4 octets, invalid=0xffffffff

#define ZCL_TYPE_TIME_DATE          0xE1     // 4 octets, invalid=0xffffffff

#define ZCL_TYPE_TIME_UTCTIME       0xE2     // 4 octets, invalid=0xffffffff

typedef uint32_t zcl_utctime_t;
#define ZCL_UTCTIME_INVALID      0xFFFFFFFF

typedef XBEE_PACKED(zcl_timeofday_t, {
   uint8_t  hours;      
   uint8_t  minutes;    
   uint8_t  seconds;    
   uint8_t  hundredths; 
}) zcl_timeofday_t;

typedef XBEE_PACKED(zcl_date_t, {
   uint8_t  year;       
   uint8_t  month;      
   uint8_t  day;        
   uint8_t  dayofweek;  
}) zcl_date_t;

#define ZCL_TYPE_ID_CLUSTER      0xE8        // 2 octets, invalid=0xffff

#define ZCL_TYPE_ID_ATTRIB       0xE9        // 2 octets, invalid=0xffff

#define ZCL_TYPE_ID_BACNET_OID   0xEA        // 4 octets, invalid=0xffffffff

#define ZCL_TYPE_IEEE_ADDR       0xF0        // 8 octets, invalid=all ffs

#define ZCL_TYPE_SECURITY_KEY    0xF1        // 16 octets (128-bit security key)

#define ZCL_TYPE_UNKNOWN         0xFF        // 0 octets

// DEVNOTE: May be necessary to add pragmas to pack these structures on
//          non-embedded platforms.

typedef union zcl40_t {
   uint8_t     u8[5];
   XBEE_PACKED(, {
      #if BYTE_ORDER == LITTLE_ENDIAN
         uint32_t low32;
         uint8_t  high8;
      #else
         uint8_t  high8;
         uint32_t low32;
      #endif
   }) mixed;
} zcl40_t;

typedef union zcl48_t {
   uint8_t     u8[6];
   uint16_t    u16[3];
   XBEE_PACKED(, {
      #if BYTE_ORDER == LITTLE_ENDIAN
         uint32_t low32;
         uint16_t high16;
      #else
         uint16_t high16;
         uint32_t low32;
      #endif
   }) mixed;
} zcl48_t;

// load separate header containing definition of zcl64_t and macros
// to work with 64-bit integers
#include "zigbee/zcl64.h"

#define ZCL_T_INVALID      0x0F
#define ZCL_T_DISCRETE     0x80
#define ZCL_T_ANALOG       0x20
#define ZCL_T_SIGNED       0x40
#define ZCL_T_FLOAT        0x10
#define ZCL_T_REPORTABLE   (ZCL_T_ANALOG | ZCL_T_DISCRETE)


#define ZCL_T_SIZE_MASK    0x0F
#define ZCL_T_SIZE_INVALID (ZCL_T_INVALID & ZCL_T_SIZE_MASK)
#define ZCL_T_SIZE_SHORT   0x0E
#define ZCL_T_SIZE_LONG    0x0D
#define ZCL_T_SIZE_128BIT  0x0C
#define ZCL_T_SIZE_VARIABLE   0x0B

#define ZCL_TYPE_IS_ANALOG(t)       (zcl_type_info[t] & ZCL_T_ANALOG)
#define ZCL_TYPE_IS_DISCRETE(t)     (zcl_type_info[t] & ZCL_T_DISCRETE)
#define ZCL_TYPE_IS_SIGNED(t)       (zcl_type_info[t] & ZCL_T_SIGNED)
#define ZCL_TYPE_IS_REPORTABLE(t)   (zcl_type_info[t] & ZCL_T_REPORTABLE)
#define ZCL_TYPE_IS_INVALID(t)      (zcl_type_info[t] == ZCL_T_INVALID)

// documented in zcl_types.c
extern const uint8_t zcl_type_info[256];
#define ZCL_SIZE_SHORT     -1
#define ZCL_SIZE_LONG      -2
#define ZCL_SIZE_VARIABLE  -3
#define ZCL_SIZE_INVALID   -127
int zcl_sizeof_type( uint8_t type);
const char *zcl_type_name( uint8_t type);

XBEE_END_DECLS

// If compiling in Dynamic C, automatically #use the appropriate C file.
#ifdef __DC__
   #use "zcl_types.c"
#endif

#endif      // __ZIGBEE_ZCL_TYPES_H