Revision 16:12782f5d4aa4, committed 2016-12-20

Comitter:

j3

Date:

Tue Dec 20 23:57:54 2016 +0000

Parent:

15:dc35ccc0b08e

Child:

17:0ae99e97bcf5

Commit message:

Added support for gyro

Changed in this revision

--- a/bmi160.cpp	Tue Dec 20 21:20:22 2016 +0000
+++ b/bmi160.cpp	Tue Dec 20 23:57:54 2016 +0000
@@ -34,7 +34,14 @@
 #include "bmi160.h"
 
 
-const struct BMI160::AccConfig BMI160::DEFAULT_ACC_CONFIG = {SENS_2G, ACC_US_OFF, ACC_BWP_2, ACC_ODR_8};
+const struct BMI160::AccConfig BMI160::DEFAULT_ACC_CONFIG = {SENS_2G, 
+                                                             ACC_US_OFF, 
+                                                             ACC_BWP_2, 
+                                                             ACC_ODR_8};
+                                                             
+const struct BMI160::GyroConfig BMI160::DEFAULT_GYRO_CONFIG = {DPS_2000, 
+                                                               GYRO_BWP_2, 
+                                                               GYRO_ODR_8};
     
 
 //*****************************************************************************
@@ -66,7 +73,7 @@
 
 
 //*****************************************************************************
-int32_t BMI160::setAccConfig(const AccConfig &config)
+int32_t BMI160::setSensorConfig(const AccConfig &config)
 {
     uint8_t data[2];
     
@@ -79,7 +86,19 @@
 
 
 //*****************************************************************************
-int32_t BMI160::getAccConfig(AccConfig &config)
+int32_t BMI160::setSensorConfig(const GyroConfig &config)
+{
+    uint8_t data[2];
+    
+    data[0] = ((config.bwp << GYRO_BWP_POS) | (config.odr << GYRO_ODR_POS));
+    data[1] = config.range;
+    
+    return writeBlock(GYR_CONF, GYR_RANGE, data);
+}
+
+
+//*****************************************************************************
+int32_t BMI160::getSensorConfig(AccConfig &config)
 {
     uint8_t data[2];
     int32_t rtnVal = readBlock(ACC_CONF, ACC_RANGE, data);
@@ -92,7 +111,7 @@
         ((data[0] & ACC_US_MASK) >> ACC_US_POS));
         config.bwp = static_cast<BMI160::AccBandWidthParam>(
         ((data[0] & ACC_BWP_MASK) >> ACC_BWP_POS));
-        config.odr = static_cast<BMI160::AccOutPutDataRate>(
+        config.odr = static_cast<BMI160::AccOutputDataRate>(
         ((data[0] & ACC_ODR_MASK) >> ACC_ODR_POS));
     }
     
@@ -101,7 +120,27 @@
 
 
 //*****************************************************************************
-int32_t BMI160::getAccAxis(SensorAxis axis, AxisData &data, AccRange range)
+int32_t BMI160::getSensorConfig(GyroConfig &config)
+{
+    uint8_t data[2];
+    int32_t rtnVal = readBlock(GYR_CONF, GYR_RANGE, data);
+    
+    if(rtnVal == RTN_NO_ERROR)
+    {
+        config.range = static_cast<BMI160::GyroRange>(
+        (data[1] & GYRO_RANGE_MASK));
+        config.bwp = static_cast<BMI160::GyroBandWidthParam>(
+        ((data[0] & GYRO_BWP_MASK) >> GYRO_BWP_POS));
+        config.odr = static_cast<BMI160::GyroOutputDataRate>(
+        ((data[0] & GYRO_ODR_MASK) >> GYRO_ODR_POS));
+    }
+    
+    return rtnVal;
+}
+
+
+//*****************************************************************************
+int32_t BMI160::getSensorAxis(SensorAxis axis, AxisData &data, AccRange range)
 {
     uint8_t localData[2];
     int32_t rtnVal;
@@ -150,10 +189,66 @@
     
     return rtnVal;
 }
+
+
+//*****************************************************************************
+int32_t BMI160::getSensorAxis(SensorAxis axis, AxisData &data, GyroRange range)
+{
+    uint8_t localData[2];
+    int32_t rtnVal;
+    
+    switch(axis)
+    {
+        case X_AXIS:
+            rtnVal = readBlock(DATA_8, DATA_9, localData);
+        break;
+        
+        case Y_AXIS:
+            rtnVal = readBlock(DATA_10, DATA_11, localData);
+        break;
+        
+        case Z_AXIS:
+            rtnVal = readBlock(DATA_12, DATA_13, localData);
+        break;
+        
+        default:
+            rtnVal = -1;
+        break;
+    }
+    
+    if(rtnVal == RTN_NO_ERROR)
+    {
+        data.raw = ((localData[1] << 8) | localData[0]);
+        switch(range)
+        {
+            case DPS_2000:
+                data.scaled = (data.raw/SENS_2000_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_1000:
+                data.scaled = (data.raw/SENS_1000_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_500:
+                data.scaled = (data.raw/SENS_500_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_250:
+                data.scaled = (data.raw/SENS_250_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_125:
+                data.scaled = (data.raw/SENS_125_DPS_LSB_PER_DPS);
+            break;
+        }
+    }
+    
+    return rtnVal;
+}
     
 
 //*****************************************************************************    
-int32_t BMI160::getAccXYZ(SensorData &data, AccRange range)
+int32_t BMI160::getSensorXYZ(SensorData &data, AccRange range)
 {
     uint8_t localData[6];
     int32_t rtnVal = readBlock(DATA_14, DATA_19, localData);
@@ -196,8 +291,60 @@
 }
 
 
+//*****************************************************************************    
+int32_t BMI160::getSensorXYZ(SensorData &data, GyroRange range)
+{
+    uint8_t localData[6];
+    int32_t rtnVal = readBlock(DATA_8, DATA_13, localData);
+    
+    if(rtnVal == RTN_NO_ERROR)
+    {
+        data.xAxis.raw = ((localData[1] << 8) | localData[0]);
+        data.yAxis.raw = ((localData[3] << 8) | localData[2]);
+        data.zAxis.raw = ((localData[5] << 8) | localData[4]);
+        
+        switch(range)
+        {
+            case DPS_2000:
+                data.xAxis.scaled = (data.xAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
+                data.yAxis.scaled = (data.yAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
+                data.zAxis.scaled = (data.zAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_1000:
+                data.xAxis.scaled = (data.xAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
+                data.yAxis.scaled = (data.yAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
+                data.zAxis.scaled = (data.zAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_500:
+                data.xAxis.scaled = (data.xAxis.raw/SENS_500_DPS_LSB_PER_DPS);
+                data.yAxis.scaled = (data.yAxis.raw/SENS_500_DPS_LSB_PER_DPS);
+                data.zAxis.scaled = (data.zAxis.raw/SENS_500_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_250:
+                data.xAxis.scaled = (data.xAxis.raw/SENS_250_DPS_LSB_PER_DPS);
+                data.yAxis.scaled = (data.yAxis.raw/SENS_250_DPS_LSB_PER_DPS);
+                data.zAxis.scaled = (data.zAxis.raw/SENS_250_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_125:
+                data.xAxis.scaled = (data.xAxis.raw/SENS_125_DPS_LSB_PER_DPS);
+                data.yAxis.scaled = (data.yAxis.raw/SENS_125_DPS_LSB_PER_DPS);
+                data.zAxis.scaled = (data.zAxis.raw/SENS_125_DPS_LSB_PER_DPS);
+            break;
+        }
+    }
+    
+    return rtnVal;
+}
+
+
 //***************************************************************************** 
-int32_t BMI160::getAccXYZandSensorTime(SensorData &data, SensorTime &sensorTime, AccRange range)
+int32_t BMI160::getSensorXYZandSensorTime(SensorData &data, 
+                                          SensorTime &sensorTime, 
+                                          AccRange range)
 {
     uint8_t localData[9];
     int32_t rtnVal = readBlock(DATA_14, SENSORTIME_2, localData);
@@ -244,6 +391,149 @@
 
 
 //***************************************************************************** 
+int32_t BMI160::getSensorXYZandSensorTime(SensorData &data, 
+                                          SensorTime &sensorTime, 
+                                          GyroRange range)
+{
+    uint8_t localData[16];
+    int32_t rtnVal = readBlock(DATA_8, SENSORTIME_2, localData);
+    if(rtnVal == RTN_NO_ERROR)
+    {
+        data.xAxis.raw = ((localData[1] << 8) | localData[0]);
+        data.yAxis.raw = ((localData[3] << 8) | localData[2]);
+        data.zAxis.raw = ((localData[5] << 8) | localData[4]);
+        
+        switch(range)
+        {
+            case DPS_2000:
+                data.xAxis.scaled = (data.xAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
+                data.yAxis.scaled = (data.yAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
+                data.zAxis.scaled = (data.zAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_1000:
+                data.xAxis.scaled = (data.xAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
+                data.yAxis.scaled = (data.yAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
+                data.zAxis.scaled = (data.zAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_500:
+                data.xAxis.scaled = (data.xAxis.raw/SENS_500_DPS_LSB_PER_DPS);
+                data.yAxis.scaled = (data.yAxis.raw/SENS_500_DPS_LSB_PER_DPS);
+                data.zAxis.scaled = (data.zAxis.raw/SENS_500_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_250:
+                data.xAxis.scaled = (data.xAxis.raw/SENS_250_DPS_LSB_PER_DPS);
+                data.yAxis.scaled = (data.yAxis.raw/SENS_250_DPS_LSB_PER_DPS);
+                data.zAxis.scaled = (data.zAxis.raw/SENS_250_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_125:
+                data.xAxis.scaled = (data.xAxis.raw/SENS_125_DPS_LSB_PER_DPS);
+                data.yAxis.scaled = (data.yAxis.raw/SENS_125_DPS_LSB_PER_DPS);
+                data.zAxis.scaled = (data.zAxis.raw/SENS_125_DPS_LSB_PER_DPS);
+            break;
+        }
+        
+        sensorTime.raw = ((localData[14] << 16) | (localData[13] << 8) | 
+                           localData[12]);
+        sensorTime.seconds = (sensorTime.raw * SENSOR_TIME_LSB);
+    }
+    
+    return rtnVal;
+}
+
+
+//***************************************************************************** 
+int32_t BMI160::getGyroAccXYZandSensorTime(SensorData &accData, 
+                                           SensorData &gyroData, 
+                                           SensorTime &sensorTime, 
+                                           AccRange accRange, 
+                                           GyroRange gyroRange)
+{
+    uint8_t localData[16];
+    int32_t rtnVal = readBlock(DATA_8, SENSORTIME_2, localData);
+    if(rtnVal == RTN_NO_ERROR)
+    {
+        gyroData.xAxis.raw = ((localData[1] << 8) | localData[0]);
+        gyroData.yAxis.raw = ((localData[3] << 8) | localData[2]);
+        gyroData.zAxis.raw = ((localData[5] << 8) | localData[4]);
+        
+        accData.xAxis.raw = ((localData[7] << 8) | localData[6]);
+        accData.yAxis.raw = ((localData[9] << 8) | localData[8]);
+        accData.zAxis.raw = ((localData[11] << 8) | localData[10]);
+        
+        switch(gyroRange)
+        {
+            case DPS_2000:
+                gyroData.xAxis.scaled = (gyroData.xAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
+                gyroData.yAxis.scaled = (gyroData.yAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
+                gyroData.zAxis.scaled = (gyroData.zAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_1000:
+                gyroData.xAxis.scaled = (gyroData.xAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
+                gyroData.yAxis.scaled = (gyroData.yAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
+                gyroData.zAxis.scaled = (gyroData.zAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_500:
+                gyroData.xAxis.scaled = (gyroData.xAxis.raw/SENS_500_DPS_LSB_PER_DPS);
+                gyroData.yAxis.scaled = (gyroData.yAxis.raw/SENS_500_DPS_LSB_PER_DPS);
+                gyroData.zAxis.scaled = (gyroData.zAxis.raw/SENS_500_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_250:
+                gyroData.xAxis.scaled = (gyroData.xAxis.raw/SENS_250_DPS_LSB_PER_DPS);
+                gyroData.yAxis.scaled = (gyroData.yAxis.raw/SENS_250_DPS_LSB_PER_DPS);
+                gyroData.zAxis.scaled = (gyroData.zAxis.raw/SENS_250_DPS_LSB_PER_DPS);
+            break;
+            
+            case DPS_125:
+                gyroData.xAxis.scaled = (gyroData.xAxis.raw/SENS_125_DPS_LSB_PER_DPS);
+                gyroData.yAxis.scaled = (gyroData.yAxis.raw/SENS_125_DPS_LSB_PER_DPS);
+                gyroData.zAxis.scaled = (gyroData.zAxis.raw/SENS_125_DPS_LSB_PER_DPS);
+            break;
+        }
+        
+        switch(accRange)
+        {
+            case SENS_2G:
+                accData.xAxis.scaled = (accData.xAxis.raw/SENS_2G_LSB_PER_G);
+                accData.yAxis.scaled = (accData.yAxis.raw/SENS_2G_LSB_PER_G);
+                accData.zAxis.scaled = (accData.zAxis.raw/SENS_2G_LSB_PER_G);
+            break;
+            
+            case SENS_4G:
+                accData.xAxis.scaled = (accData.xAxis.raw/SENS_4G_LSB_PER_G);
+                accData.yAxis.scaled = (accData.yAxis.raw/SENS_4G_LSB_PER_G);
+                accData.zAxis.scaled = (accData.zAxis.raw/SENS_4G_LSB_PER_G);
+            break;
+            
+            case SENS_8G:
+                accData.xAxis.scaled = (accData.xAxis.raw/SENS_8G_LSB_PER_G);
+                accData.yAxis.scaled = (accData.yAxis.raw/SENS_8G_LSB_PER_G);
+                accData.zAxis.scaled = (accData.zAxis.raw/SENS_8G_LSB_PER_G);
+            break;
+            
+            case SENS_16G:
+                accData.xAxis.scaled = (accData.xAxis.raw/SENS_16G_LSB_PER_G);
+                accData.yAxis.scaled = (accData.yAxis.raw/SENS_16G_LSB_PER_G);
+                accData.zAxis.scaled = (accData.zAxis.raw/SENS_16G_LSB_PER_G);
+            break;
+        }
+        
+        sensorTime.raw = ((localData[14] << 16) | (localData[13] << 8) | 
+                           localData[12]);
+        sensorTime.seconds = (sensorTime.raw * SENSOR_TIME_LSB);
+    }
+    
+    return rtnVal;
+}
+
+
+//***************************************************************************** 
 int32_t BMI160::getSensorTime(SensorTime &sensorTime)
 {
     uint8_t localData[3];

--- a/bmi160.h	Tue Dec 20 21:20:22 2016 +0000
+++ b/bmi160.h	Tue Dec 20 23:57:54 2016 +0000
@@ -256,7 +256,7 @@
     static const uint8_t ACC_RANGE_POS = 0x00;
     
     ///Accelerometer output data rates
-    enum AccOutPutDataRate
+    enum AccOutputDataRate
     {
         ACC_ODR_1 = 1,  ///< 25/32Hz
         ACC_ODR_2,      ///< 25/16Hz
@@ -275,9 +275,9 @@
     ///Accelerometer bandwidth parameters
     enum AccBandWidthParam
     {
-        ACC_BWP_0 = 0, ///< Average 1 cycle
-        ACC_BWP_1,     ///< Average 2 cycles
-        ACC_BWP_2,     ///< Average 4 cycles, use this setting when acc_us = 0
+        ACC_BWP_0 = 0, ///< Average 1 cycle;  when acc_us = 0 OSR4
+        ACC_BWP_1,     ///< Average 2 cycles; when acc_us = 0 OSR2
+        ACC_BWP_2,     ///< Average 4 cycles; when acc_us = 0 normal mode
         ACC_BWP_3,     ///< Average 8 cycles
         ACC_BWP_4,     ///< Average 16 cycles
         ACC_BWP_5,     ///< Average 32 cycles
@@ -298,7 +298,7 @@
         SENS_2G = 0x03,  ///<Accelerometer range +-2G
         SENS_4G = 0x05,  ///<Accelerometer range +-4G
         SENS_8G = 0x08,  ///<Accelerometer range +-8G
-        SENS_16G = 0x0C, ///<Accelerometer range +-16G
+        SENS_16G = 0x0C ///<Accelerometer range +-16G
     };
     
     static const float SENS_2G_LSB_PER_G = 16384.0F;
@@ -312,7 +312,7 @@
         AccRange range;        ///<Accelerometer range
         AccUnderSampling us;   ///<Accelerometr undersampling mode
         AccBandWidthParam bwp; ///<Accelerometer bandwidth param
-        AccOutPutDataRate odr; ///<Accelerometr output data rate
+        AccOutputDataRate odr; ///<Accelerometr output data rate
     };
     
     ///Accelerometer default configuration
@@ -323,7 +323,61 @@
     ///@name GYR_CONF(0x42) and GYR_RANGE(0x43) 
     ///Data for configuring gyroscope
     ///@{
-        
+    
+    static const uint8_t GYRO_ODR_MASK = 0x0F;
+    static const uint8_t GYRO_ODR_POS = 0x00;
+    static const uint8_t GYRO_BWP_MASK = 0x30;
+    static const uint8_t GYRO_BWP_POS = 0x04;
+    static const uint8_t GYRO_RANGE_MASK = 0x07;
+    static const uint8_t GYRO_RANGE_POS = 0x00;
+    
+    ///Gyroscope output data rates
+    enum GyroOutputDataRate
+    {
+        GYRO_ODR_6 = 0x06,  ///<25Hz 
+        GYRO_ODR_7 = 0x07,  ///<50Hz
+        GYRO_ODR_8 = 0x08,  ///<100Hz
+        GYRO_ODR_9 = 0x09,  ///<200Hz
+        GYRO_ODR_10 = 0x0A, ///<400Hz
+        GYRO_ODR_11 = 0x0B, ///<800Hz
+        GYRO_ODR_12 = 0x0C, ///<1600Hz
+        GYRO_ODR_13 = 0x0D  ///<3200Hz
+    };
+    
+    ///Gyroscope bandwidth paramaters
+    enum GyroBandWidthParam
+    {
+        GYRO_BWP_0 = 0, ///<OSR4 Over Sampling Rate of 4
+        GYRO_BWP_1,     ///<OSR2 Over Sampling Rate of 2
+        GYRO_BWP_2      ///<Normal Mode, Equidistant Sampling
+    };
+    
+    ///Gyroscope ranges
+    enum GyroRange
+    {
+        DPS_2000 = 0, ///<+-2000dps, 16.4LSB/dps
+        DPS_1000,     ///<+-1000dps, 32.8LSB/dps
+        DPS_500,      ///<+-500dps, 65.6LSB/dps
+        DPS_250,      ///<+-250dps, 131.2LSB/dps
+        DPS_125       ///<+-125dps, 262.4LSB/dps, 
+    };
+    
+    static const float SENS_2000_DPS_LSB_PER_DPS = 16.4F;
+    static const float SENS_1000_DPS_LSB_PER_DPS = 32.8F;
+    static const float SENS_500_DPS_LSB_PER_DPS = 65.6F;
+    static const float SENS_250_DPS_LSB_PER_DPS = 131.2F;
+    static const float SENS_125_DPS_LSB_PER_DPS = 262.4F;
+    
+    ///Gyroscope configuration data structure    
+    struct GyroConfig
+    {
+        GyroRange range;        ///<Gyroscope range
+        GyroBandWidthParam bwp; ///<Gyroscope bandwidth param
+        GyroOutputDataRate odr; ///<Gyroscope output data rate
+    };
+    
+    ///Gyroscope default configuration
+    static const GyroConfig DEFAULT_GYRO_CONFIG;
     ///@}
     
     
@@ -439,71 +493,99 @@
     int32_t setSensorPowerMode(Sensors sensor, PowerModes pwrMode);
     
     
-    ///@brief Configure Accelerometer.\n
+    ///@brief Configure sensor.\n
     ///
     ///On Entry:
-    ///@param[in] config - Accelerometer configuration 
+    ///@param[in] config - sSensor configuration data structure
     ///
     ///On Exit:
     ///@param[out] none
     ///
     ///@returns 0 on success, non 0 on failure
-    int32_t setAccConfig(const AccConfig &config);
+    int32_t setSensorConfig(const AccConfig &config);
+    int32_t setSensorConfig(const GyroConfig &config);
     
     
-    ///@brief Get accelerometer configuration.\n
+    ///@brief Get sensor configuration.\n
     ///
     ///On Entry:
-    ///@param[in] config - Accelerometer configuration data structure
+    ///@param[in] config - Sensor configuration data structure
     ///
     ///On Exit:
-    ///@param[out] config - on success, holds accelerometer's current 
+    ///@param[out] config - on success, holds sensor's current 
     ///configuration
     ///
     ///@returns 0 on success, non 0 on failure
-    int32_t getAccConfig(AccConfig &config);
+    int32_t getSensorConfig(AccConfig &config);
+    int32_t getSensorConfig(GyroConfig &config);
     
     
-    ///@brief Get accelerometer axis as float.\n
+    ///@brief Get sensor axis.\n
     ///
     ///On Entry:
     ///@param[in] axis - Sensor axis
     ///@param[in] data - AxisData structure
-    ///@param[in] range - Accelerometer range
+    ///@param[in] range - Sensor range
     ///
     ///On Exit:
     ///@param[out] data - Structure holds raw and scaled axis data
     ///
     ///@returns 0 on success, non 0 on failure
-    int32_t getAccAxis(SensorAxis axis, AxisData &data, AccRange range);
+    int32_t getSensorAxis(SensorAxis axis, AxisData &data, AccRange range);
+    int32_t getSensorAxis(SensorAxis axis, AxisData &data, GyroRange range);
     
     
-    ///@brief Get accelerometer xyz axis as float.\n
+    ///@brief Get sensor xyz axis.\n
     ///
     ///On Entry:
     ///@param[in] data - SensorData structure
-    ///@param[in] range - Accelerometer range
+    ///@param[in] range - Sensor range
     ///
     ///On Exit:
     ///@param[out] data - Structure holds raw and scaled data for all three axis
     ///
     ///@returns 0 on success, non 0 on failure
-    int32_t getAccXYZ(SensorData &data, AccRange range); 
+    int32_t getSensorXYZ(SensorData &data, AccRange range);
+    int32_t getSensorXYZ(SensorData &data, GyroRange range);
     
     
-    ///@brief Get accelerometer xyz axis and sensor time.\n
+    ///@brief Get sensor xyz axis and sensor time.\n
     ///
     ///On Entry:
     ///@param[in] data - SensorData structure
     ///@param[in] sensorTime - SensorTime structure for data
-    ///@param[in] range - Accelerometer range
+    ///@param[in] range - Sensor range
     ///
     ///On Exit:
     ///@param[out] data - Structure holds raw and scaled data for all three axis
     ///@param[out] sensorTime - Holds sensor time on success
     ///
     ///@returns 0 on success, non 0 on failure
-    int32_t getAccXYZandSensorTime(SensorData &data, SensorTime &sensorTime, AccRange range); 
+    int32_t getSensorXYZandSensorTime(SensorData &data, SensorTime &sensorTime, 
+                                      AccRange range);
+    int32_t getSensorXYZandSensorTime(SensorData &data, SensorTime &sensorTime, 
+                                      GyroRange range);
+    
+    
+    ///@brief Get Gyroscope/Accelerometer data and sensor time.\n
+    ///
+    ///On Entry:
+    ///@param[in] accData -  Sensor data structure for accelerometer
+    ///@param[in] gyroData - Sensor data structure for gyroscope
+    ///@param[in] sensorTime - SensorTime data structure
+    ///@param[in] accRange - Accelerometer range
+    ///@param[in] gyroRange - Gyroscope range
+    ///
+    ///On Exit:
+    ///@param[out] accData -  Synchronized accelerometer data
+    ///@param[out] gyroData - Synchronized gyroscope data
+    ///@param[out] sensorTime - Synchronized sensor time
+    ///
+    ///@returns 0 on success, non 0 on failure
+    int32_t getGyroAccXYZandSensorTime(SensorData &accData, 
+                                       SensorData &gyroData, 
+                                       SensorTime &sensorTime, 
+                                       AccRange accRange, GyroRange gyroRange);
     
     
     ///@brief Get sensor time.\n