alexey.zholtikov/upm
1
0
Fork 0
mirror of https://github.com/eclipse/upm.git synced 2025-03-15 04:57:30 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity
upm/src/mpu9150/mpu60x0.hpp
Noel Eck edd8df4c50 encodings: Added check for non-8bit encodings in src tree. 
This commit sanitizes source files for unicode encodings which
cause failures in downstream flows (docgen, python2 module loading,
etc...).

    * Removed explicit encodings from src files
    * Replaced 2 byte character encodings with ascii encodies:
        ± -> +/-
        ° -> deg
        “ -> "
        etc...
    * Added ctest to check src tree files for non-8bit encodings

Signed-off-by: Noel Eck <noel.eck@intel.com>
2016-10-05 14:39:30 -07:00

959 lines
29 KiB
C++
Raw Blame History

/*
* Author: Jon Trulson <jtrulson@ics.com>
* Copyright (c) 2015 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/common.hpp>
#include <mraa/i2c.hpp>
#include <mraa/gpio.hpp>
#define MPU60X0_I2C_BUS 0
#define MPU60X0_DEFAULT_I2C_ADDR 0x68
namespace upm {
/**
* @library mpu9150
* @sensor mpu60x0
* @comname MPU60X0 3-axis Gyroscope and 3-axis Accelerometer
* @type accelerometer compass
* @man seeed
* @con i2c gpio
*
* @brief API for the MPU60X0 3-axis Gyroscope and 3-axis Accelerometer
*
* The MPU60X0 devices provide the world's first integrated 6-axis
* motion processor solution that eliminates the package-level
* gyroscope and accelerometer cross-axis misalignment associated
* with discrete solutions. The devices combine a 3-axis gyroscope
* and a 3-axis accelerometer on the same silicon die.
*
* While not all of the functionality of this device is supported
* initially, methods and register definitions are provided that
* should allow an end user to implement whatever features are
* required.
*
* @image html mpu60x0.jpg
* @snippet mpu60x0.cxx Interesting
*/
class MPU60X0 {
public:
// NOTE: These enums were composed from both the mpu6050 and
// mpu9150 register maps, since this driver was written using an
// mpu9150, but we'd like this module to be usable with a
// standalone mpu60x0.
//
// Registers and bitfields marked with an '*' in their
// comment indicate registers or bit fields present in the mpu9150
// register map, but not in the original mpu6050 register map. If
// using this module on a standalone mpu6050, you should avoid
// using those registers or bitfields marked with an *.
/**
* MPU60X0 registers
*/
typedef enum {
REG_SELF_TEST_X = 0x0d,
REG_SELF_TEST_Y = 0x0e,
REG_SELF_TEST_Z = 0x0f,
REG_SELF_TEST_A = 0x10,
REG_SMPLRT_DIV = 0x19, // sample rate divider
REG_CONFIG = 0x1a,
REG_GYRO_CONFIG = 0x1b,
REG_ACCEL_CONFIG = 0x1c,
REG_FF_THR = 0x1d, // *freefall threshold
REG_FF_DUR = 0x1e, // *freefall duration
REG_MOT_THR = 0x1f, // motion threshold
REG_MOT_DUR = 0x20, // *motion duration
REG_ZRMOT_THR = 0x21, // *zero motion threshhold
REG_ZRMOT_DUR = 0x22, // *zero motion duration
REG_FIFO_EN = 0x23,
REG_I2C_MST_CTRL = 0x24, // I2C master control
REG_I2C_SLV0_ADDR = 0x25, // I2C slave 0
REG_I2C_SLV0_REG = 0x26,
REG_I2C_SLV0_CTRL = 0x27,
REG_I2C_SLV1_ADDR = 0x28, // I2C slave 1
REG_I2C_SLV1_REG = 0x29,
REG_I2C_SLV1_CTRL = 0x2a,
REG_I2C_SLV2_ADDR = 0x2b, // I2C slave 2
REG_I2C_SLV2_REG = 0x2c,
REG_I2C_SLV2_CTRL = 0x2d,
REG_I2C_SLV3_ADDR = 0x2e, // I2C slave 3
REG_I2C_SLV3_REG = 0x2f,
REG_I2C_SLV3_CTRL = 0x30,
REG_I2C_SLV4_ADDR = 0x31, // I2C slave 4
REG_I2C_SLV4_REG = 0x32,
REG_I2C_SLV4_DO = 0x33,
REG_I2C_SLV4_CTRL = 0x34,
REG_I2C_SLV4_DI = 0x35,
REG_I2C_MST_STATUS = 0x36, // I2C master status
REG_INT_PIN_CFG = 0x37, // interrupt pin config/i2c bypass
REG_INT_ENABLE = 0x38,
// 0x39 reserved
REG_INT_STATUS = 0x3a, // interrupt status
REG_ACCEL_XOUT_H = 0x3b, // accelerometer outputs
REG_ACCEL_XOUT_L = 0x3c,
REG_ACCEL_YOUT_H = 0x3d,
REG_ACCEL_YOUT_L = 0x3e,
REG_ACCEL_ZOUT_H = 0x3f,
REG_ACCEL_ZOUT_L = 0x40,
REG_TEMP_OUT_H = 0x41, // temperature output
REG_TEMP_OUT_L = 0x42,
REG_GYRO_XOUT_H = 0x43, // gyro outputs
REG_GYRO_XOUT_L = 0x44,
REG_GYRO_YOUT_H = 0x45,
REG_GYRO_YOUT_L = 0x46,
REG_GYRO_ZOUT_H = 0x47,
REG_GYRO_ZOUT_L = 0x48,
REG_EXT_SENS_DATA_00 = 0x49, // external sensor data
REG_EXT_SENS_DATA_01 = 0x4a,
REG_EXT_SENS_DATA_02 = 0x4b,
REG_EXT_SENS_DATA_03 = 0x4c,
REG_EXT_SENS_DATA_04 = 0x4d,
REG_EXT_SENS_DATA_05 = 0x4e,
REG_EXT_SENS_DATA_06 = 0x4f,
REG_EXT_SENS_DATA_07 = 0x50,
REG_EXT_SENS_DATA_08 = 0x51,
REG_EXT_SENS_DATA_09 = 0x52,
REG_EXT_SENS_DATA_10 = 0x53,
REG_EXT_SENS_DATA_11 = 0x54,
REG_EXT_SENS_DATA_12 = 0x55,
REG_EXT_SENS_DATA_13 = 0x56,
REG_EXT_SENS_DATA_14 = 0x57,
REG_EXT_SENS_DATA_15 = 0x58,
REG_EXT_SENS_DATA_16 = 0x59,
REG_EXT_SENS_DATA_17 = 0x5a,
REG_EXT_SENS_DATA_18 = 0x5b,
REG_EXT_SENS_DATA_19 = 0x5c,
REG_EXT_SENS_DATA_20 = 0x5d,
REG_EXT_SENS_DATA_21 = 0x5e,
REG_EXT_SENS_DATA_22 = 0x5f,
REG_EXT_SENS_DATA_23 = 0x60,
REG_MOT_DETECT_STATUS = 0x61, // *
// 0x62 reserved
REG_I2C_SLV0_DO = 0x63, // I2C slave data outs
REG_I2C_SLV1_DO = 0x64,
REG_I2C_SLV2_DO = 0x65,
REG_I2C_SLV3_DO = 0x66,
REG_I2C_MST_DELAY_CTRL = 0x67,
REG_SIGNAL_PATH_RESET = 0x68, // signal path resets
REG_MOT_DETECT_CTRL = 0x69,
REG_USER_CTRL = 0x6a,
REG_PWR_MGMT_1 = 0x6b, // power management
REG_PWR_MGMT_2 = 0x6c,
// 0x6d-0x71 reserved
REG_FIFO_COUNTH = 0x72,
REG_FIFO_COUNTL = 0x73,
REG_FIFO_R_W = 0x74,
REG_WHO_AM_I = 0x75
} MPU60X0_REG_T;
/**
* CONFIG bits
*/
typedef enum {
CONFIG_DLPF_CFG0 = 0x01, // digital low-pass filter config
CONFIG_DLPF_CFG1 = 0x02,
CONFIG_DLPF_CFG2 = 0x04,
_CONFIG_DLPF_SHIFT = 0,
_CONFIG_DLPF_MASK = 7,
CONFIG_EXT_SYNC_SET0 = 0x08, // FSYNC pin config
CONFIG_EXT_SYNC_SET1 = 0x10,
CONFIG_EXT_SYNC_SET2 = 0x20,
_CONFIG_EXT_SYNC_SET_SHIFT = 3,
_CONFIG_EXT_SYNC_SET_MASK = 7
} CONFIG_BITS_T;
/**
* CONFIG DLPF_CFG values
*/
typedef enum {
DLPF_260_256 = 0, // accel/gyro bandwidth (Hz)
DLPF_184_188 = 1,
DLPF_94_98 = 2,
DLPF_44_42 = 3,
DLPF_21_20 = 4,
DLPF_10_10 = 5,
DLPF_5_5 = 6,
DLPF_RESERVED = 7
} DLPF_CFG_T;
/**
* CONFIG EXT_SYNC_SET values
*/
typedef enum {
EXT_SYNC_DISABLED = 0,
EXT_SYNC_TEMP_OUT = 1,
EXT_SYNC_GYRO_XOUT = 2,
EXT_SYNC_GYRO_YOUT = 3,
EXT_SYNC_GYRO_ZOUT = 4,
EXT_SYNC_ACCEL_XOUT = 5,
EXT_SYNC_ACCEL_YOUT = 6,
EXT_SYNC_ACCEL_ZOUT = 7
} EXT_SYNC_SET_T;
/**
* GYRO_CONFIG bits
*/
typedef enum {
// 0x01-0x04 reserved
FS_SEL0 = 0x08, // gyro full scale range
FS_SEL1 = 0x10,
_FS_SEL_SHIFT = 3,
_FS_SEL_MASK = 3,
ZG_ST = 0x20, // gyro self test bits
YG_ST = 0x40,
XG_ST = 0x80
} GRYO_CONFIG_BITS_T;
/**
* GYRO FS_SEL values
*/
typedef enum {
FS_250 = 0, // 250 deg/s, 131 LSB deg/s
FS_500 = 1, // 500 deg/s, 65.5 LSB deg/s
FS_1000 = 2, // 1000 deg/s, 32.8 LSB deg/s
FS_2000 = 3 // 2000 deg/s, 16.4 LSB deg/s
} FS_SEL_T;
/**
* ACCEL_CONFIG bits
*/
typedef enum {
// 0x01-0x04 reserved
AFS_SEL0 = 0x08, // accel full scale range
AFS_SEL1 = 0x10,
_AFS_SEL_SHIFT = 3,
_AFS_SEL_MASK = 3,
ZA_ST = 0x20, // gyro self test bits
YA_ST = 0x40,
XA_ST = 0x80
} ACCEL_CONFIG_BITS_T;
/**
* ACCEL AFS_SEL (full scaling) values
*/
typedef enum {
AFS_2 = 0, // 2g, 16384 LSB/g
AFS_4 = 1, // 4g, 8192 LSB/g
AFS_8 = 2, // 8g, 4096 LSB/g
AFS_16 = 3 // 16g, 2048 LSB/g
} AFS_SEL_T;
/**
* REG_FIFO_EN bits
*/
typedef enum {
SLV0_FIFO_EN = 0x01,
SLV1_FIFO_EN = 0x02,
SLV2_FIFO_EN = 0x04,
ACCEL_FIFO_EN = 0x08,
ZG_FIFO_EN = 0x10,
YG_FIFO_EN = 0x20,
XG_FIFO_EN = 0x40,
TEMP_FIFO_EN = 0x80
} FIFO_EN_BITS_T;
/**
* REG_I2C_MST_CTRL bits
*/
typedef enum {
I2C_MST_CLK0 = 0x01,
I2C_MST_CLK1 = 0x02,
I2C_MST_CLK2 = 0x04,
I2C_MST_CLK3 = 0x08,
_I2C_MST_CLK_SHIFT = 0,
_I2C_MST_CLK_MASK = 15,
I2C_MST_P_NSR = 0x10,
SLV_3_FIFO_EN = 0x20,
WAIT_FOR_ES = 0x40,
MULT_MST_EN = 0x80
} I2C_MST_CTRL_BITS_T;
/**
* I2C_MST_CLK values
*/
typedef enum {
MST_CLK_348 = 0, // 348Khz
MST_CLK_333 = 1,
MST_CLK_320 = 2,
MST_CLK_308 = 3,
MST_CLK_296 = 4,
MST_CLK_286 = 5,
MST_CLK_276 = 6,
MST_CLK_267 = 7,
MST_CLK_258 = 8,
MST_CLK_500 = 9,
MST_CLK_471 = 10,
MST_CLK_444 = 11,
MST_CLK_421 = 12,
MST_CLK_400 = 13,
MST_CLK_381 = 14,
MST_CLK_364 = 15
} I2C_MST_CLK_T;
/**
* REG_I2C SLV0-SLV4 _ADDR bits
*/
typedef enum {
I2C_SLV_ADDR0 = 0x01,
I2C_SLV_ADDR1 = 0x02,
I2C_SLV_ADDR2 = 0x04,
I2C_SLV_ADDR3 = 0x08,
I2C_SLV_ADDR4 = 0x10,
I2C_SLV_ADDR5 = 0x20,
I2C_SLV_ADDR6 = 0x40,
_I2C_SLV_ADDR_SHIFT = 0,
_I2C_SLV_ADDR_MASK = 127,
I2C_SLV_RW = 0x80
} I2C_SLV_ADDR_BITS_T;
/**
* REG_I2C SLV0-SLV3 _CTRL bits
*/
typedef enum {
I2C_SLV_LEN0 = 0x01,
I2C_SLV_LEN1 = 0x02,
I2C_SLV_LEN2 = 0x04,
I2C_SLV_LEN3 = 0x08,
_I2C_SLV_LEN_SHIFT = 0,
_I2C_SLV_LEN_MASK = 15,
I2C_SLV_GRP = 0x10,
I2C_SLV_REG_DIS = 0x20,
I2C_SLV_BYTE_SW = 0x40,
I2C_SLV_EN = 0x80
} I2C_SLV_CTRL_BITS_T;
/**
* REG_I2C_SLV4_CTRL bits, these are different from the SLV0-SLV3
* CRTL bits.
*
* MST_DLY is not enumerated in the register map. It configures
* the reduced access rate of i2c slaves relative to the sample
* rate. When a slave's access rate is decreased relative to the
* Sample Rate, the slave is accessed every
* 1 / (1 + I2C_MST_DLY) samples
*/
typedef enum {
I2C_MST_DLY0 = 0x01,
I2C_MST_DLY1 = 0x02,
I2C_MST_DLY2 = 0x04,
I2C_MST_DLY3 = 0x08,
I2C_MST_DLY4 = 0x10,
_I2C_MST_DLY_SHIFT = 0,
_I2C_MST_DLY_MASK = 31,
I2C_SLV4_REG_DIS = 0x20,
I2C_SLV4_INT_EN = 0x40,
I2C_SLV4_EN = 0x80
} I2C_SLV4_CTRL_BITS_T;
/**
* REG_I2C_MST_STATUS bits
*/
typedef enum {
I2C_SLV0_NACK = 0x01,
I2C_SLV1_NACK = 0x02,
I2C_SLV2_NACK = 0x04,
I2C_SLV3_NACK = 0x08,
I2C_SLV4_NACK = 0x10,
I2C_LOST_ARB = 0x20,
I2C_SLV4_DONE = 0x40,
PASS_THROUGH = 0x80
} I2C_MST_STATUS_BITS_T;
/**
* REG_INT_PIN_CFG bits
*/
typedef enum {
CLKOUT_EN = 0x01, // *
I2C_BYPASS_ENABLE = 0x02,
FSYNC_INT_EN = 0x04,
FSYNC_INT_LEVEL = 0x08,
INT_RD_CLEAR = 0x10,
LATCH_INT_EN = 0x20,
INT_OPEN = 0x40,
INT_LEVEL = 0x80
} INT_PIN_CFG_BITS_T;
/**
* REG_INT_ENABLE bits
*/
typedef enum {
DATA_RDY_EN = 0x01, // *
// 0x02, 0x04 reserved
I2C_MST_INT_EN = 0x08,
FIFO_OFLOW_EN = 0x10,
ZMOT_EN = 0x20, // *zero motion
MOT_EN = 0x40,
FF_EN = 0x80 // *freefall
} INT_ENABLE_BITS_T;
/**
* REG_INT_STATUS bits
*/
typedef enum {
DATA_RDY_INT = 0x01,
// 0x02, 0x04 reserved
I2C_MST_INT = 0x08,
FIFO_OFLOW_INT = 0x10,
ZMOT_INT = 0x20, // *zero motion
MOT_INT = 0x40,
FF_INT = 0x80 // *freefall
} INT_STATUS_BITS_T;
/**
* REG_MOT_DETECT_STATUS bits (mpu9150 only)
*/
typedef enum {
MOT_ZRMOT = 0x01, // *
// 0x02 reserved
MOT_ZPOS = 0x04, // *
MOT_ZNEG = 0x08, // *
MOT_YPOS = 0x10, // *
MOT_YNEG = 0x20, // *
MOT_XPOS = 0x40, // *
MOT_XNEG = 0x80, // *
} MOT_DETECT_STATUS_BITS_T;
/**
* REG_MST_DELAY_CTRL bits
*/
typedef enum {
I2C_SLV0_DLY_EN = 0x01,
I2C_SLV1_DLY_EN = 0x02,
I2C_SLV2_DLY_EN = 0x04,
I2C_SLV3_DLY_EN = 0x08,
I2C_SLV4_DLY_EN = 0x10,
// 0x20, 0x40, reserved
DELAY_ES_SHADOW = 0x80
} MST_DELAY_CTRL_BITS_T;
/**
* REG_SIGNAL_PATH_RESET bits
*/
typedef enum {
TEMP_RESET = 0x01,
ACCEL_RESET = 0x02,
GYRO_RESET = 0x04
// 0x08-0x80 reserved
} SIGNAL_PATH_RESET_BITS_T;
/**
* REG_MOT_DETECT_CTRL bits
*/
typedef enum {
MOT_COUNT0 = 0x01, // *
MOT_COUNT1 = 0x02, // *
_MOT_COUNT_SHIFT = 0,
_MOT_COUNT_MASK = 3,
FF_COUNT0 = 0x04, // *
FF_COUNT1 = 0x08, // *
_FF_COUNT_SHIFT = 2,
_FF_COUNT_MASK = 3,
ACCEL_ON_DELAY0 = 0x10,
ACCEL_ON_DELAY1 = 0x20,
_ACCEL_ON_DELAY_SHIFT = 4,
_ACCEL_ON_DELAY_MASK = 3
// 0x40,0x80 reserved
} MOT_DETECT_CTRL_BITS_T;
/**
* MOT_COUNT or FF_COUNT values (mpu9150 only)
*/
typedef enum {
COUNT_0 = 0, // Reset
COUNT_1 = 1, // counter decrement 1
COUNT_2 = 2, // counter decrement 2
COUNT_4 = 3 // counter decrement 4
} MOT_FF_COUNT_T;
/**
* ACCEL_ON_DELAY values
*/
typedef enum {
ON_DELAY_0 = 0, // no delay
ON_DELAY_1 = 1, // add 1ms
ON_DELAY_2 = 2, // add 2ms
ON_DELAY_3 = 3 // add 3ms
} ACCEL_ON_DELAY_T;
/**
* REG_USER_CTRL bits
*/
typedef enum {
SIG_COND_RESET = 0x01,
I2C_MST_RESET = 0x02,
FIFO_RESET = 0x04,
// 0x08 reserved
I2C_IF_DIS = 0x10,
I2C_MST_EN = 0x20,
FIFO_EN = 0x40
/// 0x80 reserved
} USER_CTRL_BITS_T;
/**
* REG_PWR_MGMT_1 bits
*/
typedef enum {
CLKSEL0 = 0x01,
CLKSEL1 = 0x02,
CLKSEL2 = 0x04,
_CLKSEL_SHIFT = 0,
_CLKSEL_MASK = 7,
TEMP_DIS = 0x08,
// 0x10 reserved
PWR_CYCLE = 0x20,
PWR_SLEEP = 0x40,
DEVICE_RESET = 0x80
} PWR_MGMT_1_BITS_T;
/**
* CLKSEL values
*/
typedef enum {
INT_8MHZ = 0, // internal 8Mhz osc
PLL_XG = 1, // PLL X axis gyro
PLL_YG = 2, // PLL Y axis gyro
PLL_ZG = 3, // PLL Z axis gyro
PLL_EXT_32KHZ = 4, // PLL with external 32.768Khz ref
PLL_EXT_19MHZ = 5, // PLL with external 19.2Mhz ref
// 6 - reserved
CLK_STOP = 7 // stops clk
} CLKSEL_T;
/**
* REG_PWR_MGMT_2 bits
*/
typedef enum {
STBY_ZG = 0x01,
STBY_YG = 0x02,
STBY_XG = 0x04,
STBY_ZA = 0x08,
STBY_YA = 0x10,
STBY_XA = 0x20,
LP_WAKE_CTRL0 = 0x40,
LP_WAKE_CTRL1 = 0x80,
_LP_WAKE_CTRL_SHIFT = 6,
_LP_WAKE_CTRL_MASK = 3
} PWR_MGMT_2_BITS_T;
/**
* LP_WAKE_CTRL values
*/
typedef enum {
LP_WAKE_1_25 = 0, // wakeup feq: 1.25hz
LP_WAKE_5 = 1, // 5hz
LP_WAKE_20 = 2, // 20hz
LP_WAKE_40 = 3, // 40hz
} LP_WAKE_CRTL_T;
/**
* mpu60x0 constructor
*
* @param bus i2c bus to use
* @param address the address for this device
*/
MPU60X0(int bus=MPU60X0_I2C_BUS, uint8_t address=MPU60X0_DEFAULT_I2C_ADDR);
/**
* MPU60X0 Destructor
*/
~MPU60X0();
/**
* set up initial values and start operation
*
* @return true if successful
*/
bool init();
/**
* take a measurement and store the current sensor values
* internally. Note, these user facing registers are only updated
* from the internal device sensor values when the i2c serial
* traffic is 'idle'. So, if you are reading the values too fast,
* the bus may never be idle, and you will just end up reading
* the same values over and over.
*
* Unfortunately, it is is not clear how long 'idle' actually
* means, so if you see this behavior, reduce the rate at which
* you are calling update().
*
*/
void update();
/**
* read a register
*
* @param reg the register to read
* @return the value of the register
*/
uint8_t readReg(uint8_t reg);
/**
* read contiguous refister into a buffer
*
* @param reg the register to start reading at
* @param buffer the buffer to store the results
* @param len the number of registers to read
* @return the value of the register
*/
void readRegs(uint8_t reg, uint8_t *buffer, int len);
/**
* write to a register
*
* @param reg the register to write to
* @param val the value to write
* @return true if successful, false otherwise
*/
bool writeReg(uint8_t reg, uint8_t val);
/**
* enable or disable device sleep
*
* @param enable true to put device to sleep, false to wake up
* @return true if successful, false otherwise
*/
bool setSleep(bool enable);
/**
* specify the clock source for the device to use
*
* @param clk one of the CLKSEL_T values
* @return true if successful, false otherwise
*/
bool setClockSource(CLKSEL_T clk);
/**
* set the scaling mode of the gyroscope
*
* @param scale one of the FS_SEL_T values
* @return true if successful, false otherwise
*/
bool setGyroscopeScale(FS_SEL_T scale);
/**
* set the scaling mode of the accelerometer
*
* @param scale one of the AFS_SEL_T values
* @return true if successful, false otherwise
*/
bool setAccelerometerScale(AFS_SEL_T scale);
/**
* set the Low Pass Digital filter. This enables filtering (if
* non-0) of the accelerometer and gyro outputs.
*
* @param scale one of the DLPF_CFG_T values
* @return true if successful, false otherwise
*/
bool setDigitalLowPassFilter(DLPF_CFG_T dlp);
/**
* set the sample rate divider. This register specifies the
* divider from the gyro output rate used to generate the Sample
* Rate. The sensor registor output, FIFO output, DMP sampling
* and motion detection are all based on the Sample Rate.
*
* The Sample Rate is generated by dividing the gyro output rate
* by this register:
*
* Sample Rate = Gyro output rate / (1 + sample rate divider).
*
* The Gyro output rate is 8Khz when the Digital Low Pass Filter
* (DLPF) is 0 or 7 (DLPF_260_256 or DLPF_RESERVED), and 1Khz
* otherwise.
*
* @param scale one of the DLPF_CFG_T values
* @return true if successful, false otherwise
*/
bool setSampleRateDivider(uint8_t div);
/**
* get the current Sample Rate divider
*
* @return the current sample rate divider
*/
uint8_t getSampleRateDivider();
/**
* get the accelerometer values
*
* @param x the returned x value, if arg is non-NULL
* @param y the returned y value, if arg is non-NULL
* @param z the returned z value, if arg is non-NULL
* @return true if successful, false otherwise
*/
void getAccelerometer(float *x, float *y, float *z);
/**
* get the gyroscope values
*
* @param x the returned x value, if arg is non-NULL
* @param y the returned y value, if arg is non-NULL
* @param z the returned z value, if arg is non-NULL
* @return true if successful, false otherwise
*/
void getGyroscope(float *x, float *y, float *z);
#if defined(SWIGJAVA) || defined(JAVACALLBACK)
/**
* get the accelerometer values
*
* @return Array containing X, Y, Z accelerometer values
*/
float *getAccelerometer();
/**
* get the gyroscope values
*
* @return Array containing X, Y, Z gyroscope values
*/
float *getGyroscope();
#endif
/**
* get the temperature value
*
* @return the temperature value in degrees Celsius
*/
virtual float getTemperature();
/**
* enable onboard temperature measurement sensor
*
* @param enable true to enable temperature sensor, false to disable
* @return true if successful, false otherwise
*/
bool enableTemperatureSensor(bool enable);
/**
* configure external sync. An external signal connected to the
* FSYNC pin can be sampled by configuring EXT_SYNC_SET. Signal
* changes to the FSYNC pin are latched so that short strobes may
* be captured. The latched FSYNC signal will be sampled at the
* Sampling Rate, as defined in register 25. After sampling, the
* latch will reset to the current FSYNC signal state.
*
* The sampled value will be reported in place of the least
* significant bit in a sensor data register determined by the
* value of EXT_SYNC_SET
*
* @param val one of the EXT_SYNC_SET_T values
* @return true if successful, false otherwise
*/
bool setExternalSync(EXT_SYNC_SET_T val);
/**
* enable I2C Bypass. Enabling this feature allows devices on the
* MPU60X0 auxiliary I2C bus to be visible on the MCU's I2C bus.
*
* @param enable true to I2C bypass
* @return true if successful, false otherwise
*/
bool enableI2CBypass(bool enable);
/**
* set the motion detection threshold for interrupt generation.
* Motion is detected when the absolute value of any of the
* accelerometer measurements exceeds this Motion detection
* threshold.
*
* @param thr threshold
* @return true if successful, false otherwise
*/
bool setMotionDetectionThreshold(uint8_t thr);
/**
* return the interrupt status register.
*
* @return the interrupt status word (see INT_STATUS_BITS_T)
*/
uint8_t getInterruptStatus();
/**
* set the interrupt enables
*
* @param enables bitmask of INT_ENABLE_BITS_T values to enable
* @return true if successful, false otherwise
*/
bool setInterruptEnables(uint8_t enables);
/**
* get the current interrupt enables register
*
* @return bitmask of INT_ENABLE_BITS_T values
*/
uint8_t getInterruptEnables();
/**
* set the interrupt pin configuration
*
* @param cfg bitmask of INT_PIN_CFG_BITS_T values
* @return true if successful, false otherwise
*/
bool setInterruptPinConfig(uint8_t cfg);
/**
* get the current interrupt pin configuration
*
* @return bitmask of INT_PIN_CFG_BITS_T values
*/
uint8_t getInterruptPinConfig();
/**
* install an interrupt handler.
*
* @param gpio gpio pin to use as interrupt pin
* @param level the interrupt trigger level (one of mraa::Edge
* values). Make sure that you have configured the interrupt pin
* (setInterruptPinConfig()) properly for whatever level you
* choose.
* @param isr the interrupt handler, accepting a void * argument
* @param arg the argument to pass the the interrupt handler
*/
#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
/**
* uninstall a previously installed interrupt handler
*
*/
void uninstallISR();
protected:
// uncompensated accelerometer and gyroscope values
float m_accelX;
float m_accelY;
float m_accelZ;
float m_gyroX;
float m_gyroY;
float m_gyroZ;
// uncompensated temperature value
float m_temp;
// accelerometer and gyro scaling factors, depending on their Full
// Scale settings.
float m_accelScale;
float m_gyroScale;
private:
mraa::I2c m_i2c;
uint8_t m_addr;
mraa::Gpio *m_gpioIRQ;
};
}
Reference in New Issue View Git Blame Copy Permalink