bno055.hpp

/*
 * Author: Jon Trulson <jtrulson@ics.com>
 * Copyright (c) 2016 Intel Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#pragma once

#include <string>
#include <mraa/i2c.hpp>
#include <mraa/gpio.hpp>

#define BNO055_I2C_BUS 0
#define BNO055_DEFAULT_ADDR 0x28

namespace upm {

  class BNO055 {
  public:
    // The chip ID, for verification in the ctor.
    const uint8_t BNO055_CHIPID = 0xa0;

    // number of bytes of stored calibration data
    const int calibrationDataNumBytes = 22;

    // NOTE: Reserved registers should not be written into.  Reading
    // from them will return indeterminate values.
    //
    // The register map is divided into two pages - page 1 contains
    // sensor specific configuration registers, and page 0 contains all
    // other configuration data and sensor output registers.

    typedef enum : uint8_t {
      // The first register listed here is the page ID register.  It
      // is the same on both pages, and selects or indicates the
      // currently active register page.

      REG_PAGE_ID                      = 0x07,

      // Page 0
      REG_CHIP_ID                      = 0x00,
      REG_ACC_ID                       = 0x01, // accel id
      REG_MAG_ID                       = 0x02, // mag id
      REG_GYR_ID                       = 0x03, // gyro id
      REG_SW_REV_ID_LSB                = 0x04,
      REG_SW_REV_ID_MSB                = 0x05,
      REG_BL_REV_ID                    = 0x06, // bootloader rev

      // REG_PAGE_ID = 0x07

      REG_ACC_DATA_X_LSB               = 0x08,
      REG_ACC_DATA_X_MSB               = 0x09,
      REG_ACC_DATA_Y_LSB               = 0x0a,
      REG_ACC_DATA_Y_MSB               = 0x0b,
      REG_ACC_DATA_Z_LSB               = 0x0c,
      REG_ACC_DATA_Z_MSB               = 0x0d,

      REG_MAG_DATA_X_LSB               = 0x0e,
      REG_MAG_DATA_X_MSB               = 0x0f,
      REG_MAG_DATA_Y_LSB               = 0x10,
      REG_MAG_DATA_Y_MSB               = 0x11,
      REG_MAG_DATA_Z_LSB               = 0x12,
      REG_MAG_DATA_Z_MSB               = 0x13,

      REG_GYR_DATA_X_LSB               = 0x14,
      REG_GYR_DATA_X_MSB               = 0x15,
      REG_GYR_DATA_Y_LSB               = 0x16,
      REG_GYR_DATA_Y_MSB               = 0x17,
      REG_GYR_DATA_Z_LSB               = 0x18,
      REG_GYR_DATA_Z_MSB               = 0x19,

      // euler angles
      REG_EUL_HEADING_LSB              = 0x1a,
      REG_EUL_HEADING_MSB              = 0x1b,
      REG_EUL_ROLL_LSB                 = 0x1c,
      REG_EUL_ROLL_MSB                 = 0x1d,
      REG_EUL_PITCH_LSB                = 0x1e,
      REG_EUL_PITCH_MSB                = 0x1f,

      // Quaternions
      REG_QUA_DATA_W_LSB               = 0x20,
      REG_QUA_DATA_W_MSB               = 0x21,
      REG_QUA_DATA_X_LSB               = 0x22,
      REG_QUA_DATA_X_MSB               = 0x23,
      REG_QUA_DATA_Y_LSB               = 0x24,
      REG_QUA_DATA_Y_MSB               = 0x25,
      REG_QUA_DATA_Z_LSB               = 0x26,
      REG_QUA_DATA_Z_MSB               = 0x27,

      // linear accel data
      REG_LIA_DATA_X_LSB               = 0x28,
      REG_LIA_DATA_X_MSB               = 0x29,
      REG_LIA_DATA_Y_LSB               = 0x2a,
      REG_LIA_DATA_Y_MSB               = 0x2b,
      REG_LIA_DATA_Z_LSB               = 0x2c,
      REG_LIA_DATA_Z_MSB               = 0x2d,

      // gravity vector
      REG_GRV_DATA_X_LSB               = 0x2e,
      REG_GRV_DATA_X_MSB               = 0x2f,
      REG_GRV_DATA_Y_LSB               = 0x30,
      REG_GRV_DATA_Y_MSB               = 0x31,
      REG_GRV_DATA_Z_LSB               = 0x32,
      REG_GRV_DATA_Z_MSB               = 0x33,

      REG_TEMPERATURE                  = 0x34,

      REG_CALIB_STAT                   = 0x35, // calibration status
      REG_ST_RESULT                    = 0x36, // selftest result

      REG_INT_STA                      = 0x37, // interrupt status

      REG_SYS_CLK_STATUS               = 0x38,

      REG_SYS_STATUS                   = 0x39,
      REG_SYS_ERROR                    = 0x3a,

      REG_UNIT_SEL                     = 0x3b,

      // 0x3c reserved

      REG_OPER_MODE                    = 0x3d, // operating mode
      REG_POWER_MODE                   = 0x3e,

      REG_SYS_TRIGGER                  = 0x3f,
      REG_TEMP_SOURCE                  = 0x40, // temperature src

      REG_AXIS_MAP_CONFIG              = 0x41,
      REG_AXIS_MAP_SIGN                = 0x42,

      // 0x43-0x54 reserved

      // stored configuration data
      REG_ACC_OFFSET_X_LSB             = 0x55,
      REG_ACC_OFFSET_X_MSB             = 0x56,
      REG_ACC_OFFSET_Y_LSB             = 0x57,
      REG_ACC_OFFSET_Y_MSB             = 0x58,
      REG_ACC_OFFSET_Z_LSB             = 0x59,
      REG_ACC_OFFSET_Z_MSB             = 0x5a,

      REG_MAG_OFFSET_X_LSB             = 0x5b,
      REG_MAG_OFFSET_X_MSB             = 0x5c,
      REG_MAG_OFFSET_Y_LSB             = 0x5d,
      REG_MAG_OFFSET_Y_MSB             = 0x5e,
      REG_MAG_OFFSET_Z_LSB             = 0x5f,
      REG_MAG_OFFSET_Z_MSB             = 0x60,

      REG_GYR_OFFSET_X_LSB             = 0x61,
      REG_GYR_OFFSET_X_MSB             = 0x62,
      REG_GYR_OFFSET_Y_LSB             = 0x63,
      REG_GYR_OFFSET_Y_MSB             = 0x64,
      REG_GYR_OFFSET_Z_LSB             = 0x65,
      REG_GYR_OFFSET_Z_MSB             = 0x66,

      REG_ACC_RADIUS_LSB               = 0x67,
      REG_ACC_RADIUS_MSB               = 0x68,

      REG_MAG_RADIUS_LSB               = 0x69,
      REG_MAG_RADIUS_MSB               = 0x6a,

      // 0x6b-0x7f reserved
      // end of page 0

      // Page 1

      // 0x00-0x06 reserved
      // 0x07 - page id

      REG_ACC_CONFIG                   = 0x08,
      REG_MAG_CONFIG                   = 0x09,
      REG_GYR_CONFIG0                  = 0x0a,
      REG_GYR_CONFIG1                  = 0x0b,
      REG_ACC_SLEEP_CONFIG             = 0x0c,
      REG_GYR_SLEEP_CONFIG             = 0x0d,

      // 0x0e reserved
      REG_INT_MSK                      = 0x0f,
      REG_INT_EN                       = 0x10,

      REG_ACC_AM_THRES                 = 0x11,
      REG_ACC_INT_SETTINGS             = 0x12,
      REG_ACC_HG_DURATION              = 0x13,
      REG_ACC_HG_THRES                 = 0x14,
      REG_ACC_NM_THRES                 = 0x15,
      REG_ACC_NM_SET                   = 0x16,

      REG_GYR_INT_SETTING              = 0x17,
      REG_GYR_HR_X_SET                 = 0x18,
      REG_GYR_DUR_X                    = 0x19,
      REG_GYR_HR_Y_SET                 = 0x1a,
      REG_GYR_DUR_Y                    = 0x1b,
      REG_GYR_HR_Z_SET                 = 0x1c,
      REG_GYR_DUR_Z                    = 0x1d,
      REG_GYR_AM_THRES                 = 0x1e,
      REG_GYR_AM_SET                   = 0x1f,

      // 0x20-0x4f reserved

      // 16 byte (0x50-0x5f) unique ID
      REG_BNO_UNIQUE_ID                = 0x50

      // 0x60-0x7f reserved
    } REGS_T;

    // Page 0 register enumerants

    typedef enum {
      CALIB_STAT_MAG0                  = 0x01,
      CALIB_STAT_MAG1                  = 0x02,
      _CALIB_STAT_MAG_MASK             = 3,
      _CALIB_STAT_MAG_SHIFT            = 0,

      CALIB_STAT_ACC0                  = 0x04,
      CALIB_STAT_ACC1                  = 0x08,
      _CALIB_STAT_ACC_MASK             = 3,
      _CALIB_STAT_ACC_SHIFT            = 2,

      CALIB_STAT_GYR0                  = 0x10,
      CALIB_STAT_GYR1                  = 0x20,
      _CALIB_STAT_GYR_MASK             = 3,
      _CALIB_STAT_GYR_SHIFT            = 4,

      CALIB_STAT_SYS0                  = 0x40,
      CALIB_STAT_SYS1                  = 0x80,
      _CALIB_STAT_SYS_MASK             = 3,
      _CALIB_STAT_SYS_SHIFT            = 6
    } CALIB_STAT_BITS_T;

    typedef enum {
      ST_RESULT_ACC                    = 0x01,
      ST_RESULT_MAG                    = 0x02,
      ST_RESULT_GYR                    = 0x04,
      ST_RESULT_MCU                    = 0x08
      // 0x10-0x80 reserved
    } ST_RESULT_BITS_T;

    typedef enum {
      // 0x01-0x02 reserved
      INT_STA_GYRO_AM                  = 0x04, // gyro any-motion
      INT_STA_GYR_HIGH_RATE            = 0x08,
      // 0x010 reserved
      INT_STA_ACC_HIGH_G               = 0x20,
      INT_STA_ACC_AM                   = 0x40, // accel any-motion
      INT_STA_ACC_NM                   = 0x80  // accel no-motion
    } INT_STA_BITS_T;

    typedef enum {
      SYS_CLK_STATUS_ST_MAIN_CLK       = 0x01
      // 0x02-0x80 reserved
    } SYS_CLK_STATUS_BITS_T;

    typedef enum {
      SYS_STATUS_IDLE                   = 0,
      SYS_STATUS_SYS_ERR                = 1,
      SYS_STATUS_INIT_PERIPHERALS       = 2,
      SYS_STATUS_SYSTEM_INIT            = 3,
      SYS_STATUS_EXECUTING_SELFTEST     = 4,
      SYS_STATUS_FUSION_RUNNING         = 5,
      SYS_STATUS_NO_FUSION_RUNNING      = 6
    } SYS_STATUS_T;

    typedef enum {
      SYS_ERR_NOERROR                   = 0,
      SYS_ERR_PERIPH_INIT_ERROR         = 1,
      SYS_ERR_SYS_INIT_ERROR            = 2,
      SYS_ERR_SELFTEST_FAIL_ERROR       = 3,
      SYS_ERR_REG_VAL_OUTOFRANGE_ERROR  = 4,
      SYS_ERR_REG_ADDR_OUTOFRANGE_ERROR = 5,
      SYS_ERR_REG_WRITE_ERROR           = 6,
      SYS_ERR_LP_MODE_NOT_AVAIL_ERROR   = 7,
      SYS_ERR_ACC_PWR_MODE_NOT_AVAIL_ERROR = 8,
      SYS_ERR_FUSION_CONFIG_ERROR       = 9,
      SYS_ERR_SENSOR_CONFIG_ERROR       = 10
    } SYS_ERR_T;


    typedef enum {
      UNIT_SEL_ACC_UNIT                = 0x01, // 0=m/s^2, 1=mg
      UNIT_SEL_GYR_UNIT                = 0x02, // 0=dps, 1=rps
      UNIT_SEL_EUL_UNIT                = 0x04, // 0=degrees, 1=radians
      // 0x08 reserved
      UNIT_SEL_TEMP_UNIT               = 0x10, // 0=C, 1=F
      // 0x20-0x40 reserved
      UNIT_SEL_ORI_ANDROID_WINDOWS     = 0x80 // 0=windows orient, 1=android
    } UNIT_SEL_BITS_T;

    typedef enum {
      OPR_MODE_OPERATION_MODE0         = 0x01,
      OPR_MODE_OPERATION_MODE1         = 0x02,
      OPR_MODE_OPERATION_MODE2         = 0x04,
      OPR_MODE_OPERATION_MODE3         = 0x08,
      _OPR_MODE_OPERATION_MODE_MASK    = 15,
      _OPR_MODE_OPERATION_MODE_SHIFT   = 0
      // 0x10-0x80 reserved
    } OPR_MODE_BITS_T;

    typedef enum {
      OPERATION_MODE_CONFIGMODE        = 0,
      OPERATION_MODE_ACCONLY           = 1,
      OPERATION_MODE_MAGONLY           = 2,
      OPERATION_MODE_GYROONLY          = 3,
      OPERATION_MODE_ACCMAG            = 4,
      OPERATION_MODE_ACCGYRO           = 5,
      OPERATION_MODE_MAGGYRO           = 6,
      OPERATION_MODE_AMG               = 7,
      // fusion modes
      OPERATION_MODE_IMU               = 8,
      OPERATION_MODE_COMPASS           = 9,
      OPERATION_MODE_M4G               = 10,
      OPERATION_MODE_NDOF_FMC_OFF      = 11,
      OPERATION_MODE_NDOF              = 12
    } OPERATION_MODES_T;

    typedef enum {
      PWR_MODE_POWER_MODE0             = 0x01,
      PWR_MODE_POWER_MODE1             = 0x02,
      _PWR_MODE_POWER_MODE_MASK        = 3,
      _PWR_MODE_POWER_MODE_SHIFT       = 0
      // 0x04-0x80 reserved
    } PWR_MODE_BITS_T;

    typedef enum {
      POWER_MODE_NORMAL                = 0,
      POWER_MODE_LOW                   = 1,
      POWER_MODE_SUSPEND               = 2
    } POWER_MODES_T;

    typedef enum {
      SYS_TRIGGER_SELF_TEST            = 0x01,
      // 0x02-0x10 reserved
      SYS_TRIGGER_RST_SYS              = 0x20,
      SYS_TRIGGER_RST_INT              = 0x40,
      SYS_TRIGGER_CLK_SEL              = 0x80
    } SYS_TRIGGER_BITS_T;

    typedef enum {
      TEMP_SOURCE_TEMP_SOURCE0         = 0x01,
      TEMP_SOURCE_TEMP_SOURCE1         = 0x02,
      _TEMP_SOURCE_TEMP_SOURCE_MASK    = 3,
      _TEMP_SOURCE_TEMP_SOURCE_SHIFT   = 0
      // 0x04-0x80 reserved
    } TEMP_SOURCE_BITS_T;

    typedef enum {
      TEMP_SOURCE_ACC                  = 0,
      TEMP_SOURCE_GYR                  = 1
    } TEMP_SOURCES_T;

    typedef enum {
      AXIS_MAP_CONFIG_REMAPPED_X_VAL0  = 0x01,
      AXIS_MAP_CONFIG_REMAPPED_X_VAL1  = 0x02,
      _AXIS_MAP_CONFIG_REMAPPED_X_VAL_MASK = 3,
      _AXIS_MAP_CONFIG_REMAPPED_X_VAL_SHIFT = 0,

      AXIS_MAP_CONFIG_REMAPPED_Y_VAL0  = 0x04,
      AXIS_MAP_CONFIG_REMAPPED_Y_VAL1  = 0x08,
      _AXIS_MAP_CONFIG_REMAPPED_Y_VAL_MASK = 3,
      _AXIS_MAP_CONFIG_REMAPPED_Y_VAL_SHIFT = 2,

      AXIS_MAP_CONFIG_REMAPPED_Z_VAL0  = 0x10,
      AXIS_MAP_CONFIG_REMAPPED_Z_VAL1  = 0x20,
      _AXIS_MAP_CONFIG_REMAPPED_Z_VAL_MASK = 3,
      _AXIS_MAP_CONFIG_REMAPPED_Z_VAL_SHIFT = 4
      // 0x40-0x80 reserved
    } AXIS_MAP_CONFIG_BITS_T;

    typedef enum {
      REMAPPED_AXIS_X                  = 0,
      REMAPPED_AXIS_Y                  = 1,
      REMAPPED_AXIS_Z                  = 2
    } REMAPPED_AXIS_T;


    typedef enum {
      AXIS_MAP_SIGN_REMAPPED_Z_SIGN    = 0x01,
      AXIS_MAP_SIGN_REMAPPED_Y_SIGN    = 0x02,
      AXIS_MAP_SIGN_REMAPPED_X_SIGN    = 0x04
      // 0x08-0x80 reserved
    } AXIS_MAP_SIGN_BITS_T;

    // Page 1 register enumerants

    typedef enum {
      ACC_CONFIG_ACC_RANGE0            = 0x01,
      ACC_CONFIG_ACC_RANGE1            = 0x02,
      _ACC_CONFIG_ACC_RANGE_MASK       = 3,
      _ACC_CONFIG_ACC_RANGE_SHIFT      = 0,

      ACC_CONFIG_ACC_BW0               = 0x04,
      ACC_CONFIG_ACC_BW1               = 0x08,
      ACC_CONFIG_ACC_BW2               = 0x10,
      _ACC_CONFIG_ACC_BW_MASK          = 7,
      _ACC_CONFIG_ACC_BW_SHIFT         = 2,

      ACC_CONFIG_ACC_PWR_MODE0         = 0x20,
      ACC_CONFIG_ACC_PWR_MODE1         = 0x40,
      ACC_CONFIG_ACC_PWR_MODE2         = 0x80,
      _ACC_CONFIG_ACC_PWR_MODE_MASK    = 7,
      _ACC_CONFIG_ACC_PWR_MODE_SHIFT   = 5
    } ACC_CONFIG_BITS_T;

    typedef enum {
      ACC_RANGE_2G                     = 0,
      ACC_RANGE_4G                     = 1,
      ACC_RANGE_8G                     = 2,
      ACC_RANGE_16G                    = 3
    } ACC_RANGE_T;

    typedef enum {
      ACC_BW_7_81                      = 0, // 7.81 Hz
      ACC_BW_15_53                     = 1,
      ACC_BW_31_25                     = 2,
      ACC_BW_62_5                      = 3,
      ACC_BW_125                       = 4, // 125 Hz
      ACC_BW_250                       = 5,
      ACC_BW_500                       = 6,
      ACC_BW_1000                      = 7
    } ACC_BW_T;

    typedef enum {
      ACC_PWR_MODE_NORMAL              = 0,
      ACC_PWR_MODE_SUSPEND             = 1,
      ACC_PWR_MODE_LOWPOWER1           = 2,
      ACC_PWR_MODE_STANDBY             = 3,
      ACC_PWR_MODE_LOWPOWER2           = 4,
      ACC_PWR_MODE_DEEPSUSPEND         = 5
    } ACC_PWR_MODE_T;

    typedef enum {
      MAG_CONFIG_MAG_ODR0              = 0x01,
      MAG_CONFIG_MAG_ODR1              = 0x02,
      MAG_CONFIG_MAG_ODR2              = 0x04,
      _MAG_CONFIG_MAG_ODR_MASK         = 7,
      _MAG_CONFIG_MAG_ODR_SHIFT        = 0,

      MAG_CONFIG_MAG_OPR_MODE0         = 0x08,
      MAG_CONFIG_MAG_OPR_MODE1         = 0x10,
      _MAG_CONFIG_MAG_OPR_MODE_MASK    = 3,
      _MAG_CONFIG_MAG_OPR_MODE_SHIFT   = 3,

      MAG_CONFIG_MAG_POWER_MODE0       = 0x20,
      MAG_CONFIG_MAG_POWER_MODE1       = 0x40,
      _MAG_CONFIG_MAG_POWER_MODE_MASK  = 3,
      _MAG_CONFIG_MAG_POWER_MODE_SHIFT = 5
      // 0x80 reserved
    } MAG_CONFIG_BITS_T;

    typedef enum {
      MAG_ODR_2                        = 0, // 2Hz
      MAG_ODR_6                        = 1,
      MAG_ODR_8                        = 2,
      MAG_ODR_10                       = 3,
      MAG_ODR_15                       = 4,
      MAG_ODR_20                       = 5,
      MAG_ODR_25                       = 6,
      MAG_ODR_30                       = 7
    } MAG_ODR_T;

    typedef enum {
      MAG_OPR_LOW                      = 0, // low power
      MAG_OPR_REGULAR                  = 1,
      MAG_OPR_ENHANCED_REGULAR         = 2,
      MAG_OPR_HIGH_ACCURACY            = 3
    } MAG_OPR_T;

    typedef enum {
      MAG_POWER_NORMAL                 = 0,
      MAG_POWER_SLEEP                  = 1,
      MAG_POWER_SUSPEND                = 2,
      MAG_POWER_FORCE_MODE             = 3
    } MAG_POWER_T;

    typedef enum {
      GYR_CONFIG0_GYR_RANGE0           = 0x01,
      GYR_CONFIG0_GYR_RANGE1           = 0x02,
      GYR_CONFIG0_GYR_RANGE2           = 0x04,
      _GYR_CONFIG0_GYR_RANGE_MASK      = 7,
      _GYR_CONFIG0_GYR_RANGE_SHIFT     = 0,

      GYR_CONFIG0_GYR_BW0              = 0x08,
      GYR_CONFIG0_GYR_BW1              = 0x10,
      GYR_CONFIG0_GYR_BW2              = 0x20,
      _GYR_CONFIG0_GYR_BW_MASK         = 7,
      _GYR_CONFIG0_GYR_BW_SHIFT        = 3
      // 0x40-0x80 reserved
    } GYR_CONFIG0_BITS_T;

    typedef enum {
      GYR_RANGE_2000                   = 0, // degrees/sec
      GYR_RANGE_1000                   = 1,
      GYR_RANGE_500                    = 2,
      GYR_RANGE_250                    = 3,
      GYR_RANGE_125                    = 4
    } GYR_RANGE_T;

    typedef enum {
      GYR_BW_523                       = 0, // Hz
      GYR_BW_230                       = 1,
      GYR_BW_116                       = 2,
      GYR_BW_47                        = 3,
      GYR_BW_23                        = 4,
      GYR_BW_12                        = 5,
      GYR_BW_64                        = 6,
      GYR_BW_32                        = 7
    } GYR_BW_T;

    typedef enum {
      GYR_CONFIG1_GYR_POWER_MODE0      = 0x01,
      GYR_CONFIG1_GYR_POWER_MODE1      = 0x02,
      GYR_CONFIG1_GYR_POWER_MODE2      = 0x04,
      _GYR_CONFIG1_GYR_POWER_MODE_MASK = 7,
      _GYR_CONFIG1_GYR_POWER_MODE_SHIFT = 0
      // 0x08-0x80 reserved
    } GYR_CONFIG1_BITS_T;

    typedef enum {
      GYR_POWER_MODE_NORMAL            = 0,
      GYR_POWER_MODE_FAST_POWERUP      = 1,
      GYR_POWER_MODE_DEEP_SUSPEND      = 2,
      GYR_POWER_MODE_SUSPEND           = 3,
      GYR_POWER_MODE_ADVANCED_POWERSAVE= 4
    } GYR_POWER_MODE_T;

    typedef enum {
      ACC_SLEEP_CONFIG_SLP_MODE        = 0x01, // 0=event, 1=equidistant sample

      ACC_SLEEP_CONFIG_ACC_SLP_DUR0    = 0x02,
      ACC_SLEEP_CONFIG_ACC_SLP_DUR1    = 0x04,
      ACC_SLEEP_CONFIG_ACC_SLP_DUR2    = 0x08,
      ACC_SLEEP_CONFIG_ACC_SLP_DUR3    = 0x10,
      _ACC_SLEEP_CONFIG_ACC_SLP_DUR_MASK = 15,
      _ACC_SLEEP_CONFIG_ACC_SLP_DUR_SHIFT = 1
      // 0x20-0x80 reserved
    } ACC_SLEEP_CONFIG_BITS_T;

    typedef enum {
      ACC_SLP_DUR_0_5                  = 0, // 0.5ms
      // same for 1-5

      ACC_SLP_DUR_1                    = 6, // 1ms
      ACC_SLP_DUR_2                    = 7,
      ACC_SLP_DUR_4                    = 8,
      ACC_SLP_DUR_6                    = 9,
      ACC_SLP_DUR_10                   = 10,
      ACC_SLP_DUR_25                   = 11,
      ACC_SLP_DUR_50                   = 12,
      ACC_SLP_DUR_100                  = 13,
      ACC_SLP_DUR_500                  = 14
      // 15 = 1ms
    } ACC_SLP_DUR_T;

    typedef enum {
      GYR_SLEEP_CONFIG_GYR_SLEEP_DUR0  = 0x01,
      GYR_SLEEP_CONFIG_GYR_SLEEP_DUR1  = 0x02,
      GYR_SLEEP_CONFIG_GYR_SLEEP_DUR2  = 0x04,
      _GYR_SLEEP_CONFIG_GYR_SLEEP_DUR_MASK = 7,
      _GYR_SLEEP_CONFIG_GYR_SLEEP_DUR_SHIFT = 0,

      GYR_SLEEP_CONFIG_GYR_AUTO_SLP_DUR0 = 0x08,
      GYR_SLEEP_CONFIG_GYR_AUTO_SLP_DUR1 = 0x10,
      GYR_SLEEP_CONFIG_GYR_AUTO_SLP_DUR2 = 0x20,
      _GYR_SLEEP_CONFIG_GYR_AUTO_SLP_DUR_MASK = 7,
      _GYR_SLEEP_CONFIG_GYR_AUTO_SLP_DUR_SHIFT = 3
      // 0x40-0x80 reserved
    } GYR_SLEEP_CONFIG_BITS_T;

    typedef enum {
      GYR_SLEEP_DUR_2                  = 0, // 2ms
      GYR_SLEEP_DUR_4                  = 1,
      GYR_SLEEP_DUR_5                  = 2,
      GYR_SLEEP_DUR_8                  = 3,
      GYR_SLEEP_DUR_10                 = 4,
      GYR_SLEEP_DUR_15                 = 5,
      GYR_SLEEP_DUR_18                 = 6,
      GYR_SLEEP_DUR_20                 = 7
    } GYR_SLEEP_DUR_T;

    typedef enum {
      // 0 = illegal
      GYR_AUTO_SLP_DUR_4               = 1, // ms
      GYR_AUTO_SLP_DUR_5               = 2,
      GYR_AUTO_SLP_DUR_8               = 3,
      GYR_AUTO_SLP_DUR_10              = 4,
      GYR_AUTO_SLP_DUR_15              = 5,
      GYR_AUTO_SLP_DUR_20              = 6,
      GYR_AUTO_SLP_DUR_40              = 7
    } GYR_AUTO_SLP_DUR_T;

    typedef enum {
      // 0x00-0x02 reserved
      INT_GYRO_AM                      = 0x04, // gyro any-motion
      INT_GYRO_HIGH_RATE               = 0x08,
      // 0x10 reserved
      INT_ACC_HIGH_G                   = 0x20,
      INT_ACC_AM                       = 0x40, // acc any-motion
      INT_ACC_NM                       = 0x80, // acc no-motion
    } INT_BITS_T;

    typedef enum {
      ACC_INT_SETTINGS_AM_DUR0         = 0x01,
      ACC_INT_SETTINGS_AM_DUR1         = 0x02,
      _ACC_INT_SETTINGS_AM_DUR_MASK    = 3,
      _ACC_INT_SETTINGS_AM_DUR_SHIFT   = 0,

      ACC_INT_SETTINGS_AM_NM_X_AXIS    = 0x04,
      ACC_INT_SETTINGS_AM_NM_Y_AXIS    = 0x08,
      ACC_INT_SETTINGS_AM_NM_Z_AXIS    = 0x10,

      ACC_INT_SETTINGS_HG_X_AXIS       = 0x20,
      ACC_INT_SETTINGS_HG_Y_AXIS       = 0x40,
      ACC_INT_SETTINGS_HG_Z_AXIS       = 0x80
    } ACC_INT_SETTINGS_BITS_T;

    typedef enum {
      ACC_NM_SET_SM_NM                 = 0x01, // 0=slowmotion, 1=nomotion

      ACC_NM_SET_SM_NM_DUR0            = 0x02,
      ACC_NM_SET_SM_NM_DUR1            = 0x04,
      ACC_NM_SET_SM_NM_DUR2            = 0x08,
      ACC_NM_SET_SM_NM_DUR3            = 0x10,
      ACC_NM_SET_SM_NM_DUR4            = 0x20,
      ACC_NM_SET_SM_NM_DUR5            = 0x40,
      _ACC_NM_SET_SM_NM_DUR_MASK       = 63,
      _ACC_NM_SET_SM_NM_DUR_SHIFT      = 1
      // 0x80 reserved
    } ACC_NM_SET_BITS_T;

    typedef enum {
      GYR_INT_SETTING_AM_X_AXIS        = 0x01,
      GYR_INT_SETTING_AM_Y_AXIS        = 0x02,
      GYR_INT_SETTING_AM_Z_AXIS        = 0x04,

      GYR_INT_SETTING_HR_X_AXIS        = 0x08,
      GYR_INT_SETTING_HR_Y_AXIS        = 0x10,
      GYR_INT_SETTING_HR_Z_AXIS        = 0x20,

      GYR_INT_SETTING_AM_FILT          = 0x40,
      GYR_INT_SETTING_HR_FILT          = 0x80
    } GYR_INT_SETTING_BITS_T;

    typedef enum {
      GYR_HR_XYZ_SET_HR_THRESH0        = 0x01,
      GYR_HR_XYZ_SET_HR_THRESH1        = 0x02,
      GYR_HR_XYZ_SET_HR_THRESH2        = 0x04,
      GYR_HR_XYZ_SET_HR_THRESH3        = 0x08,
      GYR_HR_XYZ_SET_HR_THRESH4        = 0x10,
      _GYR_HR_XYZ_SET_HR_THRESH_MASK   = 31,
      _GYR_HR_XYZ_SET_HR_THRESH_SHIFT  = 0,

      GYR_HR_XYZ_SET_HR_THRESH_HYST0   = 0x20,
      GYR_HR_XYZ_SET_HR_THRESH_HYST1   = 0x40,
      _GYR_HR_XYZ_SET_HR_THRESH_HYST_MASK = 3,
      _GYR_HR_XYZ_SET_HR_THRESH_HYST_SHIFT = 5
    } GYR_HR_XYZ_SET_BITS_T;

    typedef enum {
      GYR_AM_SET_SLOPE_SAMPLES0        = 0x01,
      GYR_AM_SET_SLOPE_SAMPLES1        = 0x02,
      _GYR_AM_SET_SLOPE_SAMPLES_MASK   = 3,
      _GYR_AM_SET_SLOPE_SAMPLES_SHIFT  = 0,

      GYR_AM_SET_AWAKE_DUR0            = 0x04,
      GYR_AM_SET_AWAKE_DUR1            = 0x08,
      _GYR_AM_SET_AWAKE_DUR_MASK       = 3,
      _GYR_AM_SET_AWAKE_DUR_SHIFT      = 2

      // 0x10-0x80 reserved
    } GYR_AM_SET_BITS_T;

    typedef enum {
      SLOPE_SAMPLES_8                  = 0, // 8 samples
      SLOPE_SAMPLES_16                 = 1,
      SLOPE_SAMPLES_32                 = 2,
      SLOPE_SAMPLES_64                 = 3
    } SLOPE_SAMPLES_T;

    BNO055(int bus=BNO055_I2C_BUS, uint8_t addr=BNO055_DEFAULT_ADDR);

    ~BNO055();

    void update();

    uint8_t getChipID();

    uint8_t getACCID();

    uint8_t getMAGID();

    uint8_t getGYRID();

    uint16_t getSWRevID();

    uint8_t getBootLoaderID();

    void setClockExternal(bool extClock);

    void setTemperatureSource(TEMP_SOURCES_T src);

    void setTemperatureUnits(bool celsius);

    void setOperationMode(OPERATION_MODES_T mode);

    void resetSystem();

    void getCalibrationStatus(int *mag, int *acc, int *gyr, int *sys);

    int *getCalibrationStatus();

    bool isFullyCalibrated();

    std::string readCalibrationData();

    void writeCalibrationData(std::string calibData);

    float getTemperature(bool fahrenheit=false);

    void getEulerAngles(float *heading, float *roll, float *pitch);

    float *getEulerAngles();

    void getQuaternions(float *w, float *x, float *y, float *z);

    float *getQuaternions();

    void getLinearAcceleration(float *x, float *y, float *z);

    float *getLinearAcceleration();

    void getGravityVectors(float *x, float *y, float *z);

    float *getGravityVectors();

    void getAccelerometer(float *x, float *y, float *z);

    float *getAccelerometer();

    void getMagnetometer(float *x, float *y, float *z);

    float *getMagnetometer();

    void getGyroscope(float *x, float *y, float *z);

    float *getGyroscope();

    void setAccelerationConfig(ACC_RANGE_T range, ACC_BW_T bw,
                               ACC_PWR_MODE_T pwr);

    void setMagnetometerConfig(MAG_ODR_T odr, MAG_OPR_T opr,
                               MAG_POWER_T pwr);

    void setGyroscopeConfig(GYR_RANGE_T range, GYR_BW_T bw,
                            GYR_POWER_MODE_T pwr);

    void setAccelerometerUnits(bool mg=false);

    void setGyroscopeUnits(bool radians=false);

    void setEulerUnits(bool radians=false);

    void resetInterruptStatus();

    uint8_t getInterruptStatus();

    uint8_t getInterruptEnable();

    void setInterruptEnable(uint8_t enables);

    uint8_t getInterruptMask();

    void setInterruptMask(uint8_t mask);

    SYS_STATUS_T getSystemStatus();

    SYS_ERR_T getSystemError();


#if defined(SWIGJAVA) || defined(JAVACALLBACK)
    void installISR(int gpio, mraa::Edge level, jobject runnable);
#else

    void installISR(int gpio, mraa::Edge level,
                    void (*isr)(void *), void *arg);
#endif

    void uninstallISR();

  protected:
    mraa::I2c m_i2c;
    mraa::Gpio *m_gpioIntr;
    uint8_t m_addr;

    // always stored in C
    float m_temperature;

    // uncompensated data

    // mag data
    float m_magX;
    float m_magY;
    float m_magZ;

    // acc data
    float m_accX;
    float m_accY;
    float m_accZ;

    // acc units
    float m_accUnitScale;

    // gyr data
    float m_gyrX;
    float m_gyrY;
    float m_gyrZ;

    // gyr units
    float m_gyrUnitScale;

    // eul (euler angle) data
    float m_eulHeading;
    float m_eulRoll;
    float m_eulPitch;

    // eul units
    float m_eulUnitScale;

    // qua (quaternion) data
    float m_quaW;
    float m_quaX;
    float m_quaY;
    float m_quaZ;

    // lia (linear acceleration) data
    float m_liaX;
    float m_liaY;
    float m_liaZ;

    // grv (gravity vector) data
    float m_grvX;
    float m_grvY;
    float m_grvZ;

    void clearData();
    bool updateFusionData();
    bool updateNonFusionData();
    void setPage(uint8_t page, bool force=false);

    uint8_t readReg(uint8_t reg);

    void readRegs(uint8_t reg, uint8_t *buffer, int len);

    bool writeReg(uint8_t reg, uint8_t val);

    bool writeRegs(uint8_t reg, uint8_t *buffer, int len);

  private:
    int m_currentPage;
    OPERATION_MODES_T m_currentMode;
    bool m_tempIsC;

    // Adding a private function definition for java bindings
#if defined(SWIGJAVA) || defined(JAVACALLBACK)
    void installISR(int gpio, mraa::Edge level,
                    void (*isr)(void *), void *arg);
#endif
  };
}