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); }