uint16_t LSM9DS0_begin( LSM9DS0_t* lsm_t, LMS9DS0_Init_t* init_t )
{
#if (DEBUG0==1)
uint8_t test[8];
#endif
uint8_t gTest, xmTest;
if(init_t==NULL)
init_t = &LMS_Device_Defaults;
// Store the given scales in class variables. These scale variables
// are used throughout to calculate the actual g's, DPS,and Gs's.
lsm_t->gScale = init_t->gScl;
lsm_t->aScale = init_t->aScl;
lsm_t->mScale = init_t->mScl;
// Once we have the scale values, we can calculate the resolution
// of each sensor. That's what these functions are for. One for each sensor
calcgRes(lsm_t); // Calculate DPS / ADC tick, stored in gRes variable
calcmRes(lsm_t); // Calculate Gs / ADC tick, stored in mRes variable
calcaRes(lsm_t); // Calculate g / ADC tick, stored in aRes variable
// Now, initialize our hardware interface.
#if(LSM_I2C_SUPPORT==1)
if (lsm_t->interfaceMode == MODE_I2C) // If we're using I2C
LSM_initI2C(); // Initialize I2C
else if (lsm_t->interfaceMode == MODE_SPI) // else, if we're using SPI
#endif
//LSM_initSPI(); // Initialize SPI
// To verify communication, we can read from the WHO_AM_I register of
// each device. Store those in a variable so we can return them.
gTest = gReadByte(lsm_t,WHO_AM_I_G); // Read the gyro WHO_AM_I
xmTest = xmReadByte(lsm_t,WHO_AM_I_XM); // Read the accel/mag WHO_AM_I
// Gyro initialization stuff:
initGyro(lsm_t); // This will "turn on" the gyro. Setting up interrupts, etc.
setGyroODR(lsm_t,init_t->gODR); // Set the gyro output data rate and bandwidth.
setGyroScale(lsm_t,lsm_t->gScale); // Set the gyro range
// Accelerometer initialization stuff:
initAccel(lsm_t); // "Turn on" all axes of the accel. Set up interrupts, etc.
setAccelODR(lsm_t,init_t->aODR); // Set the accel data rate.
setAccelScale(lsm_t,lsm_t->aScale); // Set the accel range.
// Magnetometer initialization stuff:
initMag(lsm_t); // "Turn on" all axes of the mag. Set up interrupts, etc.
setMagODR(lsm_t,init_t->mODR); // Set the magnetometer output data rate.
setMagScale(lsm_t,lsm_t->mScale); // Set the magnetometer's range.
LSM9DS0_Update_Ctrl(lsm_t);
lsm_t->update=UPDATE_ON_SET;
#if (DEBUG0==1)
I2CreadBytes(lsm_t->gAddress,CTRL_REG1_G,test,5);
I2CreadBytes(lsm_t->xmAddress,CTRL_REG0_XM,test,7);
#endif
// Once everything is initialized, return the WHO_AM_I registers we read:
return (xmTest << 8) | gTest;
}
void setMagScale(uint8_t mScl)
{
// We need to preserve the other bytes in CTRL_REG6_XM. So, first read it:
uint8_t temp = mReadByte(CTRL_REG2_M);
// Then mask out the mag scale bits:
temp &= 0xFF^(0x3 << 5);
switch (mScl)
{
case 8:
temp |= (0x1 << 5);
settings.mag.scale = 8;
break;
case 12:
temp |= (0x2 << 5);
settings.mag.scale = 12;
break;
case 16:
temp |= (0x3 << 5);
settings.mag.scale = 16;
break;
default: // Otherwise we'll default to 4 gauss (00)
settings.mag.scale = 4;
break;
}
// And write the new register value back into CTRL_REG6_XM:
mWriteByte(CTRL_REG2_M, temp);
// We've updated the sensor, but we also need to update our class variables
// First update mScale:
//mScale = mScl;
// Then calculate a new mRes, which relies on mScale being set correctly:
calcmRes();
}
uint16_t LSM9DS1::begin()
{
//! Todo: don't use ACCEL_GYRO_ADDRESS or MAGNETOMETER_ADDRESS, duplicating memory
constrainScales();
// Once we have the scale values, we can calculate the resolution
// of each sensor. That's what these functions are for. One for each sensor
calcgRes(); // Calculate DPS / ADC tick, stored in gRes variable
calcmRes(); // Calculate Gs / ADC tick, stored in mRes variable
calcaRes(); // Calculate g / ADC tick, stored in aRes variable
initI2C(); // Initialize I2C
// To verify communication, we can read from the WHO_AM_I register of
// each device. Store those in a variable so we can return them.
uint8_t mTest = mReadByte(WHO_AM_I_M); // Read the gyro WHO_AM_I
uint8_t xgTest = xgReadByte(WHO_AM_I_XG); // Read the accel/mag WHO_AM_I
uint16_t whoAmICombined = (xgTest << 8) | mTest;
if (whoAmICombined != ((WHO_AM_I_AG_RSP << 8) | WHO_AM_I_M_RSP))
return 0;
// Gyro initialization stuff:
initGyro(); // This will "turn on" the gyro. Setting up interrupts, etc.
// Accelerometer initialization stuff:
initAccel(); // "Turn on" all axes of the accel. Set up interrupts, etc.
// Magnetometer initialization stuff:
initMag(); // "Turn on" all axes of the mag. Set up interrupts, etc.
// Once everything is initialized, return the WHO_AM_I registers we read:
return whoAmICombined;
}
uint16_t begin(LSM9DS0_t* imu, gyro_scale gScl, accel_scale aScl,
mag_scale mScl, gyro_odr gODR, accel_odr aODR, mag_odr mODR)
{
// Store the given scales in imu struct. These scale variables
// are used throughout to calculate the actual g's, DPS,and Gs's.
imu->gScale = gScl;
imu->aScale = aScl;
imu->mScale = mScl;
// Once we have the scale values, we can calculate the resolution
// of each sensor. That's what these functions are for. One for each sensor
calcgRes(imu); // Calculate DPS / ADC tick, stored in gRes variable
calcaRes(imu); // Calculate g / ADC tick, stored in aRes variable
calcmRes(imu); // Calculate Gs / ADC tick, stored in mRes variable
// To verify communication, we can read from the WHO_AM_I register of
// each device. Store those in a variable so we can return them.
uint8_t gTest = gReadByte(imu->gyro, WHO_AM_I_G); // Read the gyro WHO_AM_I
uint8_t xmTest = xmReadByte(imu->xm, WHO_AM_I_XM); // Read the accel/mag WHO_AM_I
// Gyro initialization stuff:
initGyro(imu->gyro); // This will "turn on" the gyro. Setting up interrupts, etc.
setGyroODR(imu->gyro, gODR); // Set the gyro output data rate and bandwidth.
setGyroScale(imu, imu->gScale); // Set the gyro range
}
/* ************************************************************************** */
uint16_t LSM9DS0_begin_adv( stLSM9DS0_t * stThis,
gyro_scale gScl,
accel_scale aScl,
mag_scale mScl,
gyro_odr gODR,
accel_odr aODR,
mag_odr mODR )
{
// Default to 0xFF to indicate status is not OK
uint8_t gTest = 0xFF;
uint8_t xmTest = 0xFF;
byte byDatas;
byte byAddress = 0x1D;
byte bySubAddress = 0x0F;
// Wiat for a few millis at the beginning for the chip to boot
WAIT1_Waitms( 200 );
// Store the given scales in class variables. These scale variables
// are used throughout to calculate the actual g's, DPS,and Gs's.
stThis->gScale = gScl;
stThis->aScale = aScl;
stThis->mScale = mScl;
// Once we have the scale values, we can calculate the resolution
// of each sensor. That's what these functions are for. One for each sensor
calcgRes(stThis); // Calculate DPS / ADC tick, stored in gRes variable
calcmRes(stThis); // Calculate Gs / ADC tick, stored in mRes variable
calcaRes(stThis); // Calculate g / ADC tick, stored in aRes variable
// Now, initialize our hardware interface.
if (stThis->interfaceMode == MODE_I2C) // If we're using I2C
initI2C(stThis); // Initialize I2C
else if (stThis->interfaceMode == MODE_SPI) // else, if we're using SPI
initSPI(stThis); // Initialize SPI
// To verify communication, we can read from the WHO_AM_I register of
// each device. Store those in a variable so we can return them.
gTest = gReadByte( stThis, WHO_AM_I_G ); // Read the gyro WHO_AM_I
xmTest = xmReadByte( stThis, WHO_AM_I_XM ); // Read the accel/mag WHO_AM_I
// Gyro initialization stuff:
initGyro(stThis); // This will "turn on" the gyro. Setting up interrupts, etc.
LSM9DS0_setGyroODR(stThis, gODR); // Set the gyro output data rate and bandwidth.
LSM9DS0_setGyroScale(stThis, stThis->gScale); // Set the gyro range
// Accelerometer initialization stuff:
initAccel(stThis); // "Turn on" all axes of the accel. Set up interrupts, etc.
LSM9DS0_setAccelODR(stThis, aODR); // Set the accel data rate.
LSM9DS0_setAccelScale(stThis, stThis->aScale); // Set the accel range.
// Magnetometer initialization stuff:
initMag(stThis); // "Turn on" all axes of the mag. Set up interrupts, etc.
LSM9DS0_setMagODR(stThis, mODR); // Set the magnetometer output data rate.
LSM9DS0_setMagScale(stThis, stThis->mScale); // Set the magnetometer's range.
// Once everything is initialized, return the WHO_AM_I registers we read:
return (xmTest << 8) | gTest;
}
void LSM9DS0::setMagScale(mag_scale mScl)
{
// We need to preserve the other bytes in CTRL_REG6_XM. So, first read it:
uint8_t temp = xmReadByte(CTRL_REG6_XM);
// Then mask out the mag scale bits:
temp &= 0xFF^(0x3 << 5);
// Then shift in our new scale bits:
temp |= mScl << 5;
// And write the new register value back into CTRL_REG6_XM:
xmWriteByte(CTRL_REG6_XM, temp);
// We've updated the sensor, but we also need to update our class variables
// First update mScale:
mScale = mScl;
// Then calculate a new mRes, which relies on mScale being set correctly:
calcmRes();
}
uint16_t begin(void)
{
//! Todo: don't use _xgAddress or _mAddress, duplicating memory
_xgAddress = settings.device.agAddress;
_mAddress = settings.device.mAddress;
constrainScales();
// Once we have the scale values, we can calculate the resolution
// of each sensor. That's what these functions are for. One for each sensor
calcgRes(); // Calculate DPS / ADC tick, stored in gRes variable
calcmRes(); // Calculate Gs / ADC tick, stored in mRes variable
calcaRes(); // Calculate g / ADC tick, stored in aRes variable
if (settings.device.commInterface == IMU_MODE_I2C) // If we're using I2C
initI2C(); // Initialize I2C
else if (settings.device.commInterface == IMU_MODE_SPI) // else, if we're using SPI
initSPI(); // Initialize SPI
// To verify communication, we can read from the WHO_AM_I register of
// each device. Store those in a variable so we can return them.
uint8_t mTest = mReadByte(WHO_AM_I_M); // Read the gyro WHO_AM_I
delay(DELAY * 150);
uint8_t xgTest = xgReadByte(WHO_AM_I_XG); // Read the accel/mag WHO_AM_I
uint16_t whoAmICombined = (xgTest << 8) | mTest;
if (whoAmICombined != ((WHO_AM_I_AG_RSP << 8) | WHO_AM_I_M_RSP))
{
return 0;
}
// Gyro initialization stuff:
initGyro(); // This will "turn on" the gyro. Setting up interrupts, etc.
// Accelerometer initialization stuff:
initAccel(); // "Turn on" all axes of the accel. Set up interrupts, etc.
// Magnetometer initialization stuff:
initMag(); // "Turn on" all axes of the mag. Set up interrupts, etc.
// Once everything is initialized, return the WHO_AM_I registers we read:
return whoAmICombined;
}
uint16_t LSM9DS0::begin(gyro_scale gScl, accel_scale aScl, mag_scale mScl,
gyro_odr gODR, accel_odr aODR, mag_odr mODR)
{
// Store the given scales in class variables. These scale variables
// are used throughout to calculate the actual g's, DPS,and Gs's.
gScale = gScl;
aScale = aScl;
mScale = mScl;
// Once we have the scale values, we can calculate the resolution
// of each sensor. That's what these functions are for. One for each sensor
calcgRes(); // Calculate DPS / ADC tick, stored in gRes variable
calcmRes(); // Calculate Gs / ADC tick, stored in mRes variable
calcaRes(); // Calculate g / ADC tick, stored in aRes variable
// Now, initialize our hardware interface.
if (interfaceMode == MODE_I2C) // If we're using I2C
{} //initI2C(); // Initialize I2C
else if (interfaceMode == MODE_SPI) // else, if we're using SPI
initSPI(); // Initialize SPI
// To verify communication, we can read from the WHO_AM_I register of
// each device. Store those in a variable so we can return them.
uint8_t gTest = gReadByte(WHO_AM_I_G); // Read the gyro WHO_AM_I
uint8_t xmTest = xmReadByte(WHO_AM_I_XM); // Read the accel/mag WHO_AM_I
// Gyro initialization stuff:
initGyro(); // This will "turn on" the gyro. Setting up interrupts, etc.
setGyroODR(gODR); // Set the gyro output data rate and bandwidth.
setGyroScale(gScale); // Set the gyro range
// Accelerometer initialization stuff:
initAccel(); // "Turn on" all axes of the accel. Set up interrupts, etc.
setAccelODR(aODR); // Set the accel data rate.
setAccelScale(aScale); // Set the accel range.
// Magnetometer initialization stuff:
initMag(); // "Turn on" all axes of the mag. Set up interrupts, etc.
setMagODR(mODR); // Set the magnetometer output data rate.
setMagScale(mScale); // Set the magnetometer's range.
// Once everything is initialized, return the WHO_AM_I registers we read:
return (xmTest << 8) | gTest;
}
void setMagScale(LSM9DS0_t* lsm_t, mag_scale mScl)
{
// We need to preserve the other bytes in CTRL_REG6_XM. So, first read it:
//uint8_t temp = xmReadByte(lsm_t,CTRL_REG6_XM);
// Then mask out the mag scale bits:
lsm_t->xmCtrl[6] &= 0xFF^(0x3 << 5);
// Then shift in our new scale bits:
lsm_t->xmCtrl[6] |= mScl << 5;
// And write the new register value back into CTRL_REG6_XM:
if (lsm_t->update==UPDATE_ON_SET)
xmWriteByte(lsm_t,CTRL_REG6_XM, lsm_t->xmCtrl+6);
// We've updated the sensor, but we also need to update our class variables
// First update mScale:
lsm_t->mScale = mScl;
// Then calculate a new mRes, which relies on mScale being set correctly:
calcmRes(lsm_t);
}
