bmi160.cpp

00001 /**********************************************************************
00002 * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
00003 *
00004 * Permission is hereby granted, free of charge, to any person obtaining a
00005 * copy of this software and associated documentation files (the "Software"),
00006 * to deal in the Software without restriction, including without limitation
00007 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
00008 * and/or sell copies of the Software, and to permit persons to whom the
00009 * Software is furnished to do so, subject to the following conditions:
00010 *
00011 * The above copyright notice and this permission notice shall be included
00012 * in all copies or substantial portions of the Software.
00013 *
00014 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
00015 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00016 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
00017 * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
00018 * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
00019 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
00020 * OTHER DEALINGS IN THE SOFTWARE.
00021 *
00022 * Except as contained in this notice, the name of Maxim Integrated
00023 * Products, Inc. shall not be used except as stated in the Maxim Integrated
00024 * Products, Inc. Branding Policy.
00025 *
00026 * The mere transfer of this software does not imply any licenses
00027 * of trade secrets, proprietary technology, copyrights, patents,
00028 * trademarks, maskwork rights, or any other form of intellectual
00029 * property whatsoever. Maxim Integrated Products, Inc. retains all
00030 * ownership rights.
00031 **********************************************************************/
00032 
00033 
00034 #include "bmi160.h"
00035 
00036 
00037 const struct BMI160::AccConfig BMI160::DEFAULT_ACC_CONFIG = {SENS_2G, 
00038                                                              ACC_US_OFF, 
00039                                                              ACC_BWP_2, 
00040                                                              ACC_ODR_8};
00041                                                              
00042 const struct BMI160::GyroConfig BMI160::DEFAULT_GYRO_CONFIG = {DPS_2000, 
00043                                                                GYRO_BWP_2, 
00044                                                                GYRO_ODR_8};
00045 
00046 ///Period of internal counter
00047 static const float SENSOR_TIME_LSB = 39e-6;
00048 
00049 static const float SENS_2G_LSB_PER_G = 16384.0F;
00050 static const float SENS_4G_LSB_PER_G = 8192.0F;
00051 static const float SENS_8G_LSB_PER_G = 4096.0F;
00052 static const float SENS_16G_LSB_PER_G = 2048.0F;
00053 
00054 static const float SENS_2000_DPS_LSB_PER_DPS = 16.4F;
00055 static const float SENS_1000_DPS_LSB_PER_DPS = 32.8F;
00056 static const float SENS_500_DPS_LSB_PER_DPS = 65.6F;
00057 static const float SENS_250_DPS_LSB_PER_DPS = 131.2F;
00058 static const float SENS_125_DPS_LSB_PER_DPS = 262.4F;
00059     
00060 
00061 //*****************************************************************************
00062 int32_t BMI160::setSensorPowerMode(Sensors sensor, PowerModes pwrMode)
00063 {
00064     int32_t rtnVal = -1;
00065     
00066     switch(sensor)
00067     {
00068         case MAG:
00069             rtnVal = writeRegister(CMD, (MAG_SET_PMU_MODE | pwrMode));
00070         break;
00071         
00072         case GYRO:
00073             rtnVal = writeRegister(CMD, (GYR_SET_PMU_MODE | pwrMode));
00074         break;
00075         
00076         case ACC:
00077             rtnVal = writeRegister(CMD, (ACC_SET_PMU_MODE | pwrMode));
00078         break;
00079         
00080         default:
00081             rtnVal = -1;
00082         break;
00083     }
00084     
00085     return rtnVal;
00086 }
00087 
00088 
00089 //*****************************************************************************
00090 int32_t BMI160::setSensorConfig(const AccConfig &config)
00091 {
00092     uint8_t data[2];
00093     
00094     data[0] = ((config.us << ACC_US_POS) | (config.bwp << ACC_BWP_POS) | 
00095                (config.odr << ACC_ODR_POS));
00096     data[1] = config.range;
00097     
00098     return writeBlock(ACC_CONF, ACC_RANGE, data);
00099 }
00100 
00101 
00102 //*****************************************************************************
00103 int32_t BMI160::setSensorConfig(const GyroConfig &config)
00104 {
00105     uint8_t data[2];
00106     
00107     data[0] = ((config.bwp << GYRO_BWP_POS) | (config.odr << GYRO_ODR_POS));
00108     data[1] = config.range;
00109     
00110     return writeBlock(GYR_CONF, GYR_RANGE, data);
00111 }
00112 
00113 
00114 //*****************************************************************************
00115 int32_t BMI160::getSensorConfig(AccConfig &config)
00116 {
00117     uint8_t data[2];
00118     int32_t rtnVal = readBlock(ACC_CONF, ACC_RANGE, data);
00119     
00120     if(rtnVal == RTN_NO_ERROR)
00121     {
00122         config.range = static_cast<BMI160::AccRange>(
00123         (data[1] & ACC_RANGE_MASK));
00124         config.us = static_cast<BMI160::AccUnderSampling>(
00125         ((data[0] & ACC_US_MASK) >> ACC_US_POS));
00126         config.bwp = static_cast<BMI160::AccBandWidthParam>(
00127         ((data[0] & ACC_BWP_MASK) >> ACC_BWP_POS));
00128         config.odr = static_cast<BMI160::AccOutputDataRate>(
00129         ((data[0] & ACC_ODR_MASK) >> ACC_ODR_POS));
00130     }
00131     
00132     return rtnVal;
00133 }
00134 
00135 
00136 //*****************************************************************************
00137 int32_t BMI160::getSensorConfig(GyroConfig &config)
00138 {
00139     uint8_t data[2];
00140     int32_t rtnVal = readBlock(GYR_CONF, GYR_RANGE, data);
00141     
00142     if(rtnVal == RTN_NO_ERROR)
00143     {
00144         config.range = static_cast<BMI160::GyroRange>(
00145         (data[1] & GYRO_RANGE_MASK));
00146         config.bwp = static_cast<BMI160::GyroBandWidthParam>(
00147         ((data[0] & GYRO_BWP_MASK) >> GYRO_BWP_POS));
00148         config.odr = static_cast<BMI160::GyroOutputDataRate>(
00149         ((data[0] & GYRO_ODR_MASK) >> GYRO_ODR_POS));
00150     }
00151     
00152     return rtnVal;
00153 }
00154 
00155 
00156 //*****************************************************************************
00157 int32_t BMI160::getSensorAxis(SensorAxis axis, AxisData &data, AccRange range)
00158 {
00159     uint8_t localData[2];
00160     int32_t rtnVal;
00161     
00162     switch(axis)
00163     {
00164         case X_AXIS:
00165             rtnVal = readBlock(DATA_14, DATA_15, localData);
00166         break;
00167         
00168         case Y_AXIS:
00169             rtnVal = readBlock(DATA_16, DATA_17, localData);
00170         break;
00171         
00172         case Z_AXIS:
00173             rtnVal = readBlock(DATA_18, DATA_19, localData);
00174         break;
00175         
00176         default:
00177             rtnVal = -1;
00178         break;
00179     }
00180     
00181     if(rtnVal == RTN_NO_ERROR)
00182     {
00183         data.raw = ((localData[1] << 8) | localData[0]);
00184         switch(range)
00185         {
00186             case SENS_2G:
00187                 data.scaled = (data.raw/SENS_2G_LSB_PER_G);
00188             break;
00189             
00190             case SENS_4G:
00191                 data.scaled = (data.raw/SENS_4G_LSB_PER_G);
00192             break;
00193             
00194             case SENS_8G:
00195                 data.scaled = (data.raw/SENS_8G_LSB_PER_G);
00196             break;
00197             
00198             case SENS_16G:
00199                 data.scaled = (data.raw/SENS_16G_LSB_PER_G);
00200             break;
00201         }
00202     }
00203     
00204     return rtnVal;
00205 }
00206 
00207 
00208 //*****************************************************************************
00209 int32_t BMI160::getSensorAxis(SensorAxis axis, AxisData &data, GyroRange range)
00210 {
00211     uint8_t localData[2];
00212     int32_t rtnVal;
00213     
00214     switch(axis)
00215     {
00216         case X_AXIS:
00217             rtnVal = readBlock(DATA_8, DATA_9, localData);
00218         break;
00219         
00220         case Y_AXIS:
00221             rtnVal = readBlock(DATA_10, DATA_11, localData);
00222         break;
00223         
00224         case Z_AXIS:
00225             rtnVal = readBlock(DATA_12, DATA_13, localData);
00226         break;
00227         
00228         default:
00229             rtnVal = -1;
00230         break;
00231     }
00232     
00233     if(rtnVal == RTN_NO_ERROR)
00234     {
00235         data.raw = ((localData[1] << 8) | localData[0]);
00236         switch(range)
00237         {
00238             case DPS_2000:
00239                 data.scaled = (data.raw/SENS_2000_DPS_LSB_PER_DPS);
00240             break;
00241             
00242             case DPS_1000:
00243                 data.scaled = (data.raw/SENS_1000_DPS_LSB_PER_DPS);
00244             break;
00245             
00246             case DPS_500:
00247                 data.scaled = (data.raw/SENS_500_DPS_LSB_PER_DPS);
00248             break;
00249             
00250             case DPS_250:
00251                 data.scaled = (data.raw/SENS_250_DPS_LSB_PER_DPS);
00252             break;
00253             
00254             case DPS_125:
00255                 data.scaled = (data.raw/SENS_125_DPS_LSB_PER_DPS);
00256             break;
00257         }
00258     }
00259     
00260     return rtnVal;
00261 }
00262     
00263 
00264 //*****************************************************************************    
00265 int32_t BMI160::getSensorXYZ(SensorData &data, AccRange range)
00266 {
00267     uint8_t localData[6];
00268     int32_t rtnVal = readBlock(DATA_14, DATA_19, localData);
00269     
00270     if(rtnVal == RTN_NO_ERROR)
00271     {
00272         data.xAxis.raw = ((localData[1] << 8) | localData[0]);
00273         data.yAxis.raw = ((localData[3] << 8) | localData[2]);
00274         data.zAxis.raw = ((localData[5] << 8) | localData[4]);
00275         
00276         switch(range)
00277         {
00278             case SENS_2G:
00279                 data.xAxis.scaled = (data.xAxis.raw/SENS_2G_LSB_PER_G);
00280                 data.yAxis.scaled = (data.yAxis.raw/SENS_2G_LSB_PER_G);
00281                 data.zAxis.scaled = (data.zAxis.raw/SENS_2G_LSB_PER_G);
00282             break;
00283             
00284             case SENS_4G:
00285                 data.xAxis.scaled = (data.xAxis.raw/SENS_4G_LSB_PER_G);
00286                 data.yAxis.scaled = (data.yAxis.raw/SENS_4G_LSB_PER_G);
00287                 data.zAxis.scaled = (data.zAxis.raw/SENS_4G_LSB_PER_G);
00288             break;
00289             
00290             case SENS_8G:
00291                 data.xAxis.scaled = (data.xAxis.raw/SENS_8G_LSB_PER_G);
00292                 data.yAxis.scaled = (data.yAxis.raw/SENS_8G_LSB_PER_G);
00293                 data.zAxis.scaled = (data.zAxis.raw/SENS_8G_LSB_PER_G);
00294             break;
00295             
00296             case SENS_16G:
00297                 data.xAxis.scaled = (data.xAxis.raw/SENS_16G_LSB_PER_G);
00298                 data.yAxis.scaled = (data.yAxis.raw/SENS_16G_LSB_PER_G);
00299                 data.zAxis.scaled = (data.zAxis.raw/SENS_16G_LSB_PER_G);
00300             break;
00301         }
00302     }
00303     
00304     return rtnVal;
00305 }
00306 
00307 
00308 //*****************************************************************************    
00309 int32_t BMI160::getSensorXYZ(SensorData &data, GyroRange range)
00310 {
00311     uint8_t localData[6];
00312     int32_t rtnVal = readBlock(DATA_8, DATA_13, localData);
00313     
00314     if(rtnVal == RTN_NO_ERROR)
00315     {
00316         data.xAxis.raw = ((localData[1] << 8) | localData[0]);
00317         data.yAxis.raw = ((localData[3] << 8) | localData[2]);
00318         data.zAxis.raw = ((localData[5] << 8) | localData[4]);
00319         
00320         switch(range)
00321         {
00322             case DPS_2000:
00323                 data.xAxis.scaled = (data.xAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
00324                 data.yAxis.scaled = (data.yAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
00325                 data.zAxis.scaled = (data.zAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
00326             break;
00327             
00328             case DPS_1000:
00329                 data.xAxis.scaled = (data.xAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
00330                 data.yAxis.scaled = (data.yAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
00331                 data.zAxis.scaled = (data.zAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
00332             break;
00333             
00334             case DPS_500:
00335                 data.xAxis.scaled = (data.xAxis.raw/SENS_500_DPS_LSB_PER_DPS);
00336                 data.yAxis.scaled = (data.yAxis.raw/SENS_500_DPS_LSB_PER_DPS);
00337                 data.zAxis.scaled = (data.zAxis.raw/SENS_500_DPS_LSB_PER_DPS);
00338             break;
00339             
00340             case DPS_250:
00341                 data.xAxis.scaled = (data.xAxis.raw/SENS_250_DPS_LSB_PER_DPS);
00342                 data.yAxis.scaled = (data.yAxis.raw/SENS_250_DPS_LSB_PER_DPS);
00343                 data.zAxis.scaled = (data.zAxis.raw/SENS_250_DPS_LSB_PER_DPS);
00344             break;
00345             
00346             case DPS_125:
00347                 data.xAxis.scaled = (data.xAxis.raw/SENS_125_DPS_LSB_PER_DPS);
00348                 data.yAxis.scaled = (data.yAxis.raw/SENS_125_DPS_LSB_PER_DPS);
00349                 data.zAxis.scaled = (data.zAxis.raw/SENS_125_DPS_LSB_PER_DPS);
00350             break;
00351         }
00352     }
00353     
00354     return rtnVal;
00355 }
00356 
00357 
00358 //***************************************************************************** 
00359 int32_t BMI160::getSensorXYZandSensorTime(SensorData &data, 
00360                                           SensorTime &sensorTime, 
00361                                           AccRange range)
00362 {
00363     uint8_t localData[9];
00364     int32_t rtnVal = readBlock(DATA_14, SENSORTIME_2, localData);
00365     if(rtnVal == RTN_NO_ERROR)
00366     {
00367         data.xAxis.raw = ((localData[1] << 8) | localData[0]);
00368         data.yAxis.raw = ((localData[3] << 8) | localData[2]);
00369         data.zAxis.raw = ((localData[5] << 8) | localData[4]);
00370         
00371         switch(range)
00372         {
00373             case SENS_2G:
00374                 data.xAxis.scaled = (data.xAxis.raw/SENS_2G_LSB_PER_G);
00375                 data.yAxis.scaled = (data.yAxis.raw/SENS_2G_LSB_PER_G);
00376                 data.zAxis.scaled = (data.zAxis.raw/SENS_2G_LSB_PER_G);
00377             break;
00378             
00379             case SENS_4G:
00380                 data.xAxis.scaled = (data.xAxis.raw/SENS_4G_LSB_PER_G);
00381                 data.yAxis.scaled = (data.yAxis.raw/SENS_4G_LSB_PER_G);
00382                 data.zAxis.scaled = (data.zAxis.raw/SENS_4G_LSB_PER_G);
00383             break;
00384             
00385             case SENS_8G:
00386                 data.xAxis.scaled = (data.xAxis.raw/SENS_8G_LSB_PER_G);
00387                 data.yAxis.scaled = (data.yAxis.raw/SENS_8G_LSB_PER_G);
00388                 data.zAxis.scaled = (data.zAxis.raw/SENS_8G_LSB_PER_G);
00389             break;
00390             
00391             case SENS_16G:
00392                 data.xAxis.scaled = (data.xAxis.raw/SENS_16G_LSB_PER_G);
00393                 data.yAxis.scaled = (data.yAxis.raw/SENS_16G_LSB_PER_G);
00394                 data.zAxis.scaled = (data.zAxis.raw/SENS_16G_LSB_PER_G);
00395             break;
00396         }
00397         
00398         sensorTime.raw = ((localData[8] << 16) | (localData[7] << 8) | 
00399                            localData[6]);
00400         sensorTime.seconds = (sensorTime.raw * SENSOR_TIME_LSB);
00401     }
00402     
00403     return rtnVal;
00404 }
00405 
00406 
00407 //***************************************************************************** 
00408 int32_t BMI160::getSensorXYZandSensorTime(SensorData &data, 
00409                                           SensorTime &sensorTime, 
00410                                           GyroRange range)
00411 {
00412     uint8_t localData[16];
00413     int32_t rtnVal = readBlock(DATA_8, SENSORTIME_2, localData);
00414     if(rtnVal == RTN_NO_ERROR)
00415     {
00416         data.xAxis.raw = ((localData[1] << 8) | localData[0]);
00417         data.yAxis.raw = ((localData[3] << 8) | localData[2]);
00418         data.zAxis.raw = ((localData[5] << 8) | localData[4]);
00419         
00420         switch(range)
00421         {
00422             case DPS_2000:
00423                 data.xAxis.scaled = (data.xAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
00424                 data.yAxis.scaled = (data.yAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
00425                 data.zAxis.scaled = (data.zAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
00426             break;
00427             
00428             case DPS_1000:
00429                 data.xAxis.scaled = (data.xAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
00430                 data.yAxis.scaled = (data.yAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
00431                 data.zAxis.scaled = (data.zAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
00432             break;
00433             
00434             case DPS_500:
00435                 data.xAxis.scaled = (data.xAxis.raw/SENS_500_DPS_LSB_PER_DPS);
00436                 data.yAxis.scaled = (data.yAxis.raw/SENS_500_DPS_LSB_PER_DPS);
00437                 data.zAxis.scaled = (data.zAxis.raw/SENS_500_DPS_LSB_PER_DPS);
00438             break;
00439             
00440             case DPS_250:
00441                 data.xAxis.scaled = (data.xAxis.raw/SENS_250_DPS_LSB_PER_DPS);
00442                 data.yAxis.scaled = (data.yAxis.raw/SENS_250_DPS_LSB_PER_DPS);
00443                 data.zAxis.scaled = (data.zAxis.raw/SENS_250_DPS_LSB_PER_DPS);
00444             break;
00445             
00446             case DPS_125:
00447                 data.xAxis.scaled = (data.xAxis.raw/SENS_125_DPS_LSB_PER_DPS);
00448                 data.yAxis.scaled = (data.yAxis.raw/SENS_125_DPS_LSB_PER_DPS);
00449                 data.zAxis.scaled = (data.zAxis.raw/SENS_125_DPS_LSB_PER_DPS);
00450             break;
00451         }
00452         
00453         sensorTime.raw = ((localData[14] << 16) | (localData[13] << 8) | 
00454                            localData[12]);
00455         sensorTime.seconds = (sensorTime.raw * SENSOR_TIME_LSB);
00456     }
00457     
00458     return rtnVal;
00459 }
00460 
00461 
00462 //***************************************************************************** 
00463 int32_t BMI160::getGyroAccXYZandSensorTime(SensorData &accData, 
00464                                            SensorData &gyroData, 
00465                                            SensorTime &sensorTime, 
00466                                            AccRange accRange, 
00467                                            GyroRange gyroRange)
00468 {
00469     uint8_t localData[16];
00470     int32_t rtnVal = readBlock(DATA_8, SENSORTIME_2, localData);
00471     if(rtnVal == RTN_NO_ERROR)
00472     {
00473         gyroData.xAxis.raw = ((localData[1] << 8) | localData[0]);
00474         gyroData.yAxis.raw = ((localData[3] << 8) | localData[2]);
00475         gyroData.zAxis.raw = ((localData[5] << 8) | localData[4]);
00476         
00477         accData.xAxis.raw = ((localData[7] << 8) | localData[6]);
00478         accData.yAxis.raw = ((localData[9] << 8) | localData[8]);
00479         accData.zAxis.raw = ((localData[11] << 8) | localData[10]);
00480         
00481         switch(gyroRange)
00482         {
00483             case DPS_2000:
00484                 gyroData.xAxis.scaled = (gyroData.xAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
00485                 gyroData.yAxis.scaled = (gyroData.yAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
00486                 gyroData.zAxis.scaled = (gyroData.zAxis.raw/SENS_2000_DPS_LSB_PER_DPS);
00487             break;
00488             
00489             case DPS_1000:
00490                 gyroData.xAxis.scaled = (gyroData.xAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
00491                 gyroData.yAxis.scaled = (gyroData.yAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
00492                 gyroData.zAxis.scaled = (gyroData.zAxis.raw/SENS_1000_DPS_LSB_PER_DPS);
00493             break;
00494             
00495             case DPS_500:
00496                 gyroData.xAxis.scaled = (gyroData.xAxis.raw/SENS_500_DPS_LSB_PER_DPS);
00497                 gyroData.yAxis.scaled = (gyroData.yAxis.raw/SENS_500_DPS_LSB_PER_DPS);
00498                 gyroData.zAxis.scaled = (gyroData.zAxis.raw/SENS_500_DPS_LSB_PER_DPS);
00499             break;
00500             
00501             case DPS_250:
00502                 gyroData.xAxis.scaled = (gyroData.xAxis.raw/SENS_250_DPS_LSB_PER_DPS);
00503                 gyroData.yAxis.scaled = (gyroData.yAxis.raw/SENS_250_DPS_LSB_PER_DPS);
00504                 gyroData.zAxis.scaled = (gyroData.zAxis.raw/SENS_250_DPS_LSB_PER_DPS);
00505             break;
00506             
00507             case DPS_125:
00508                 gyroData.xAxis.scaled = (gyroData.xAxis.raw/SENS_125_DPS_LSB_PER_DPS);
00509                 gyroData.yAxis.scaled = (gyroData.yAxis.raw/SENS_125_DPS_LSB_PER_DPS);
00510                 gyroData.zAxis.scaled = (gyroData.zAxis.raw/SENS_125_DPS_LSB_PER_DPS);
00511             break;
00512         }
00513         
00514         switch(accRange)
00515         {
00516             case SENS_2G:
00517                 accData.xAxis.scaled = (accData.xAxis.raw/SENS_2G_LSB_PER_G);
00518                 accData.yAxis.scaled = (accData.yAxis.raw/SENS_2G_LSB_PER_G);
00519                 accData.zAxis.scaled = (accData.zAxis.raw/SENS_2G_LSB_PER_G);
00520             break;
00521             
00522             case SENS_4G:
00523                 accData.xAxis.scaled = (accData.xAxis.raw/SENS_4G_LSB_PER_G);
00524                 accData.yAxis.scaled = (accData.yAxis.raw/SENS_4G_LSB_PER_G);
00525                 accData.zAxis.scaled = (accData.zAxis.raw/SENS_4G_LSB_PER_G);
00526             break;
00527             
00528             case SENS_8G:
00529                 accData.xAxis.scaled = (accData.xAxis.raw/SENS_8G_LSB_PER_G);
00530                 accData.yAxis.scaled = (accData.yAxis.raw/SENS_8G_LSB_PER_G);
00531                 accData.zAxis.scaled = (accData.zAxis.raw/SENS_8G_LSB_PER_G);
00532             break;
00533             
00534             case SENS_16G:
00535                 accData.xAxis.scaled = (accData.xAxis.raw/SENS_16G_LSB_PER_G);
00536                 accData.yAxis.scaled = (accData.yAxis.raw/SENS_16G_LSB_PER_G);
00537                 accData.zAxis.scaled = (accData.zAxis.raw/SENS_16G_LSB_PER_G);
00538             break;
00539         }
00540         
00541         sensorTime.raw = ((localData[14] << 16) | (localData[13] << 8) | 
00542                            localData[12]);
00543         sensorTime.seconds = (sensorTime.raw * SENSOR_TIME_LSB);
00544     }
00545     
00546     return rtnVal;
00547 }
00548 
00549 
00550 //***************************************************************************** 
00551 int32_t BMI160::getSensorTime(SensorTime &sensorTime)
00552 {
00553     uint8_t localData[3];
00554     int32_t rtnVal = readBlock(SENSORTIME_0, SENSORTIME_2, localData);
00555     
00556     if(rtnVal == RTN_NO_ERROR)
00557     {
00558         sensorTime.raw = ((localData[2] << 16) | (localData[1] << 8) | 
00559                            localData[0]);
00560         sensorTime.seconds = (sensorTime.raw * SENSOR_TIME_LSB);
00561     }
00562     
00563     return rtnVal;
00564 }
00565 
00566 
00567 //*****************************************************************************
00568 int32_t BMI160::getTemperature(float *temp)
00569 {
00570     uint8_t data[2];
00571     uint16_t rawTemp;
00572     
00573     int32_t rtnVal = readBlock(TEMPERATURE_0, TEMPERATURE_1, data);
00574     if(rtnVal == RTN_NO_ERROR)
00575     {
00576         rawTemp = ((data[1] << 8) | data[0]);
00577         if(rawTemp & 0x8000)
00578         {
00579             *temp = (23.0F - ((0x10000 - rawTemp)/512.0F));
00580         }
00581         else
00582         {
00583             *temp = ((rawTemp/512.0F) + 23.0F);
00584         }
00585     }
00586     
00587     return rtnVal;
00588 }