From 20f724e223ea9635c1763bae9579fd599fee6641 Mon Sep 17 00:00:00 2001 From: Sandeep Mistry Date: Wed, 17 Feb 2016 08:37:19 -0500 Subject: [PATCH] Remove enums for ranges and duration, auto calibrate/set offset now enables offset, rename interrupt routines to interrupts/noInterrupts keywords.txt updates --- .../examples/Accelerometer/Accelerometer.ino | 2 +- .../AccelerometerOrientation.ino | 2 +- libraries/CurieIMU/examples/Gyro/Gyro.ino | 2 +- .../RawImuDataSerial/RawImuDataSerial.ino | 11 +- .../examples/ShockDetect/ShockDetect.ino | 6 +- .../CurieIMU/examples/StepCount/StepCount.ino | 2 +- .../CurieIMU/examples/TapDetect/TapDetect.ino | 8 +- libraries/CurieIMU/keywords.txt | 130 +- libraries/CurieIMU/src/CurieIMU.cpp | 1109 ++++++++++++++++- libraries/CurieIMU/src/CurieIMU.h | 256 ++-- 10 files changed, 1213 insertions(+), 315 deletions(-) diff --git a/libraries/CurieIMU/examples/Accelerometer/Accelerometer.ino b/libraries/CurieIMU/examples/Accelerometer/Accelerometer.ino index 87070456..9032795a 100644 --- a/libraries/CurieIMU/examples/Accelerometer/Accelerometer.ino +++ b/libraries/CurieIMU/examples/Accelerometer/Accelerometer.ino @@ -33,7 +33,7 @@ void setup() { CurieIMU.begin(); // Set the accelerometer range to 2G - CurieIMU.setAccelerometerRange(CURIE_IMU_ACCELEROMETER_RANGE_2G); + CurieIMU.setAccelerometerRange(2); } void loop() { diff --git a/libraries/CurieIMU/examples/AccelerometerOrientation/AccelerometerOrientation.ino b/libraries/CurieIMU/examples/AccelerometerOrientation/AccelerometerOrientation.ino index a3fcf006..a36ee612 100644 --- a/libraries/CurieIMU/examples/AccelerometerOrientation/AccelerometerOrientation.ino +++ b/libraries/CurieIMU/examples/AccelerometerOrientation/AccelerometerOrientation.ino @@ -36,7 +36,7 @@ void setup() { CurieIMU.begin(); // Set the accelerometer range to 2G - CurieIMU.setAccelerometerRange(CURIE_IMU_ACCELEROMETER_RANGE_2G); + CurieIMU.setAccelerometerRange(2); } void loop() { diff --git a/libraries/CurieIMU/examples/Gyro/Gyro.ino b/libraries/CurieIMU/examples/Gyro/Gyro.ino index 07371f24..426a25b1 100644 --- a/libraries/CurieIMU/examples/Gyro/Gyro.ino +++ b/libraries/CurieIMU/examples/Gyro/Gyro.ino @@ -33,7 +33,7 @@ void setup() { CurieIMU.begin(); // Set the accelerometer range to 250 degrees/second - CurieIMU.setGyroRange(CURIE_IMU_GYRO_RANGE_250); + CurieIMU.setGyroRange(250); } void loop() { diff --git a/libraries/CurieIMU/examples/RawImuDataSerial/RawImuDataSerial.ino b/libraries/CurieIMU/examples/RawImuDataSerial/RawImuDataSerial.ino index 3ef1ac46..fe3524bd 100644 --- a/libraries/CurieIMU/examples/RawImuDataSerial/RawImuDataSerial.ino +++ b/libraries/CurieIMU/examples/RawImuDataSerial/RawImuDataSerial.ino @@ -84,11 +84,11 @@ void setup() { // The board must be resting in a horizontal position for // the following calibration procedure to work correctly! - Serial.print("Starting Gyroscope calibration..."); + Serial.print("Starting Gyroscope calibration and enabling offset compensation..."); CurieIMU.autoCalibrateGyroOffset(); Serial.println(" Done"); - Serial.print("Starting Acceleration calibration..."); + Serial.print("Starting Acceleration calibration and enabling offset compensation..."); CurieIMU.autoCalibrateAccelerometerOffset(X_AXIS, 0); CurieIMU.autoCalibrateAccelerometerOffset(Y_AXIS, 0); CurieIMU.autoCalibrateAccelerometerOffset(Z_AXIS, 1); @@ -106,13 +106,6 @@ void setup() { Serial.print(CurieIMU.getGyroOffset(Y_AXIS)); Serial.print("\t"); // 0 Serial.println(CurieIMU.getGyroOffset(Z_AXIS)); - - Serial.println("Enabling Gyroscope/Acceleration offset compensation"); - CurieIMU.enableGyroOffset(true); - CurieIMU.enableAccelerometerOffset(true); - - Serial.println(CurieIMU.accelerometerOffsetEnabled()); - Serial.println(CurieIMU.gyroOffsetEnabled()); } // configure Arduino LED for activity indicator diff --git a/libraries/CurieIMU/examples/ShockDetect/ShockDetect.ino b/libraries/CurieIMU/examples/ShockDetect/ShockDetect.ino index fe96941c..06c4a2e5 100644 --- a/libraries/CurieIMU/examples/ShockDetect/ShockDetect.ino +++ b/libraries/CurieIMU/examples/ShockDetect/ShockDetect.ino @@ -34,9 +34,9 @@ void setup() { CurieIMU.attachInterrupt(eventCallback); /* Enable Shock Detection */ - CurieIMU.setDetectionThreshold(CURIE_IMU_SHOCK, 192); // 1.5g - CurieIMU.setDetectionDuration(CURIE_IMU_SHOCK, CURIE_IMU_TAP_SHOCK_DURATION_50MS); // 50ms - CurieIMU.enableInterrupt(CURIE_IMU_SHOCK, true); + CurieIMU.setDetectionThreshold(CURIE_IMU_SHOCK, 1500); // 1.5g = 1500 mg + CurieIMU.setDetectionDuration(CURIE_IMU_SHOCK, 50); // 50ms + CurieIMU.interrupts(CURIE_IMU_SHOCK); Serial.println("IMU initialisation complete, waiting for events..."); } diff --git a/libraries/CurieIMU/examples/StepCount/StepCount.ino b/libraries/CurieIMU/examples/StepCount/StepCount.ino index 664efdb8..d2096dff 100644 --- a/libraries/CurieIMU/examples/StepCount/StepCount.ino +++ b/libraries/CurieIMU/examples/StepCount/StepCount.ino @@ -52,7 +52,7 @@ void setup() { // attach the eventCallback function as the // step event handler: CurieIMU.attachInterrupt(eventCallback); - CurieIMU.enableInterrupt(CURIE_IMU_STEP, true); // turn on step detection + CurieIMU.interrupts(CURIE_IMU_STEP); // turn on step detection Serial.println("IMU initialisation complete, waiting for events..."); } diff --git a/libraries/CurieIMU/examples/TapDetect/TapDetect.ino b/libraries/CurieIMU/examples/TapDetect/TapDetect.ino index e0ffa2b4..2ff8b3c0 100644 --- a/libraries/CurieIMU/examples/TapDetect/TapDetect.ino +++ b/libraries/CurieIMU/examples/TapDetect/TapDetect.ino @@ -32,16 +32,16 @@ void setup() { CurieIMU.attachInterrupt(eventCallback); // Increase Accelerometer range to allow detection of stronger taps (< 4g) - CurieIMU.setAccelerometerRange(CURIE_IMU_ACCELEROMETER_RANGE_4G); + CurieIMU.setAccelerometerRange(4); // Reduce threshold to allow detection of weaker taps (>= 750mg) - CurieIMU.setDetectionThreshold(CURIE_IMU_TAP, 6); // (6 x 125mg) + CurieIMU.setDetectionThreshold(CURIE_IMU_TAP, 750); // (750mg) // Set the time window for 2 taps to be registered as a double-tap (<= 250 milliseconds) - CurieIMU.setDetectionDuration(CURIE_IMU_DOUBLE_TAP, CURIE_IMU_DOUBLE_TAP_DURATION_250MS); + CurieIMU.setDetectionDuration(CURIE_IMU_DOUBLE_TAP, 250); // Enable Double-Tap detection - CurieIMU.enableInterrupt(CURIE_IMU_DOUBLE_TAP, true); + CurieIMU.interrupts(CURIE_IMU_DOUBLE_TAP); Serial.println("IMU initialisation complete, waiting for events..."); } diff --git a/libraries/CurieIMU/keywords.txt b/libraries/CurieIMU/keywords.txt index f19f4ca8..874baf4f 100644 --- a/libraries/CurieIMU/keywords.txt +++ b/libraries/CurieIMU/keywords.txt @@ -27,8 +27,8 @@ setAccelerometerRange KEYWORD1 autoCalibrateGyroOffset KEYWORD1 autoCalibrateAccelerometerOffset KEYWORD1 -enableGyroOffset KEYWORD1 -enableAccelerometerOffset KEYWORD1 +noGyroOffset KEYWORD1 +noAccelerometerOffset KEYWORD1 gyroOffsetEnabled KEYWORD1 accelerometerOffsetEnabled KEYWORD1 @@ -44,8 +44,9 @@ setDetectionThreshold KEYWORD1 getDetectionDuration KEYWORD1 setDetectionDuration KEYWORD1 -enableInterrupt KEYWORD1 -interruptEnabled KEYWORD1 +interrupts KEYWORD1 +noInterrupts KEYWORD1 +interruptsEnabled KEYWORD1 getInterruptBits KEYWORD1 getInterruptStatus KEYWORD1 @@ -80,111 +81,26 @@ CurieIMU KEYWORD2 # Constants (LITERAL1) ####################################### -CURIE_IMU_ACCELEROMETER_RATE_25_2HZ LITERAL1 -CURIE_IMU_ACCELEROMETER_RATE_25HZ LITERAL1 -CURIE_IMU_ACCELEROMETER_RATE_50HZ LITERAL1 -CURIE_IMU_ACCELEROMETER_RATE_100HZ LITERAL1 -CURIE_IMU_ACCELEROMETER_RATE_200HZ LITERAL1 -CURIE_IMU_ACCELEROMETER_RATE_400HZ LITERAL1 -CURIE_IMU_ACCELEROMETER_RATE_800HZ LITERAL1 -CURIE_IMU_ACCELEROMETER_RATE_1600HZ LITERAL1 - -CURIE_IMU_GYRO_RATE_25HZ LITERAL1 -CURIE_IMU_GYRO_RATE_50HZ LITERAL1 -CURIE_IMU_GYRO_RATE_100HZ LITERAL1 -CURIE_IMU_GYRO_RATE_200HZ LITERAL1 -CURIE_IMU_GYRO_RATE_400HZ LITERAL1 -CURIE_IMU_GYRO_RATE_800HZ LITERAL1 -CURIE_IMU_GYRO_RATE_1600HZ LITERAL1 -CURIE_IMU_GYRO_RATE_3200HZ LITERAL1 - -CURIE_IMU_GYRO_RANGE_2000 LITERAL1 -CURIE_IMU_GYRO_RANGE_1000 LITERAL1 -CURIE_IMU_GYRO_RANGE_500 LITERAL1 -CURIE_IMU_GYRO_RANGE_250 LITERAL1 -CURIE_IMU_GYRO_RANGE_125 LITERAL1 - -CURIE_IMU_ACCELEROMETER_RANGE_2G LITERAL1 -CURIE_IMU_ACCELEROMETER_RANGE_4G LITERAL1 -CURIE_IMU_ACCELEROMETER_RANGE_8G LITERAL1 -CURIE_IMU_ACCELEROMETER_RANGE_16G LITERAL1 +X_AXIS LITERAL1 +Y_AXIS LITERAL1 +Z_AXIS LITERAL1 + +POSITIVE LITERAL1 +NEGATIVE LITERAL1 + +CURIE_IMU_FREEFALL LITERAL1 +CURIE_IMU_SHOCK LITERAL1 +CURIE_IMU_MOTION LITERAL1 +CURIE_IMU_ZERO_MOTION LITERAL1 +CURIE_IMU_STEP LITERAL1 +CURIE_IMU_TAP LITERAL1 +CURIE_IMU_TAP_SHOCK LITERAL1 +CURIE_IMU_TAP_QUIET LITERAL1 +CURIE_IMU_DOUBLE_TAP LITERAL1 +CURIE_IMU_FIFO_FULL LITERAL1 +CURIE_IMU_DATA_READY LITERAL1 CURIE_IMU_STEP_MODE_NORMAL LITERAL1 CURIE_IMU_STEP_MODE_SENSITIVE LITERAL1 CURIE_IMU_STEP_MODE_ROBUST LITERAL1 CURIE_IMU_STEP_MODE_UNKNOWN LITERAL1 - -CURIE_IMU_DOUBLE_TAP_DURATION_50MS LITERAL1 -CURIE_IMU_DOUBLE_TAP_DURATION_100MS LITERAL1 -CURIE_IMU_DOUBLE_TAP_DURATION_150MS LITERAL1 -CURIE_IMU_DOUBLE_TAP_DURATION_200MS LITERAL1 -CURIE_IMU_DOUBLE_TAP_DURATION_250MS LITERAL1 -CURIE_IMU_DOUBLE_TAP_DURATION_375MS LITERAL1 -CURIE_IMU_DOUBLE_TAP_DURATION_500MS LITERAL1 -CURIE_IMU_DOUBLE_TAP_DURATION_700MS LITERAL1 - - -CURIE_IMU_ZERO_MOTION_DURATION_1_28S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_2_56S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_3_84S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_5_12S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_6_40S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_7_68S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_8_96S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_10_24S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_11_52S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_12_80S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_14_08S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_15_36S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_16_64S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_17_92S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_19_20S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_20_48S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_25_60S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_30_72S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_35_84S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_40_96S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_46_08S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_51_20S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_56_32S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_61_44S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_66_56S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_71_68S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_76_80S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_81_92S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_87_04S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_92_16S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_97_28S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_102_40S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_112_64S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_122_88S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_133_12S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_143_36S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_153_60S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_163_84S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_174_08S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_184_32S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_194_56S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_204_80S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_215_04S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_225_28S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_235_52S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_245_76S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_256_00S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_266_24S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_276_48S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_286_72S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_296_96S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_307_20S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_317_44S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_327_68S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_337_92S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_348_16S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_358_40S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_368_64S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_378_88S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_389_12S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_399_36S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_409_60S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_419_84S LITERAL1 -CURIE_IMU_ZERO_MOTION_DURATION_430_08S LITERAL1 diff --git a/libraries/CurieIMU/src/CurieIMU.cpp b/libraries/CurieIMU/src/CurieIMU.cpp index 39ba0c03..02284285 100644 --- a/libraries/CurieIMU/src/CurieIMU.cpp +++ b/libraries/CurieIMU/src/CurieIMU.cpp @@ -59,47 +59,235 @@ bool CurieIMUClass::begin() int CurieIMUClass::getGyroRate() { - return BMI160Class::getGyroRate(); + int rate; + + switch(BMI160Class::getGyroRate()) { + case BMI160_GYRO_RATE_25HZ: + rate = 25; + break; + + case BMI160_GYRO_RATE_50HZ: + rate = 50; + break; + + case BMI160_GYRO_RATE_100HZ: + rate = 100; + break; + + case BMI160_GYRO_RATE_200HZ: + rate = 200; + break; + + case BMI160_GYRO_RATE_400HZ: + rate = 400; + break; + + case BMI160_GYRO_RATE_800HZ: + rate = 800; + break; + + case BMI160_GYRO_RATE_1600HZ: + rate = 1600; + break; + + case BMI160_GYRO_RATE_3200HZ: + default: + rate = 3200; + break; + } + + return rate; } void CurieIMUClass::setGyroRate(int rate) { - BMI160Class::setGyroRate(rate); + BMI160GyroRate bmiRate; + + if (rate <= 25) { + bmiRate = BMI160_GYRO_RATE_25HZ; + } else if (rate <= 50) { + bmiRate = BMI160_GYRO_RATE_50HZ; + } else if (rate <= 100) { + bmiRate = BMI160_GYRO_RATE_100HZ; + } else if (rate <= 200) { + bmiRate = BMI160_GYRO_RATE_200HZ; + } else if (rate <= 400) { + bmiRate = BMI160_GYRO_RATE_400HZ; + } else if (rate <= 800) { + bmiRate = BMI160_GYRO_RATE_800HZ; + } else if (rate <= 1600) { + bmiRate = BMI160_GYRO_RATE_1600HZ; + } else { + bmiRate = BMI160_GYRO_RATE_3200HZ; + } + + BMI160Class::setGyroRate(bmiRate); } -int CurieIMUClass::getAccelerometerRate() +float CurieIMUClass::getAccelerometerRate() { - return getAccelRate(); + float rate; + + switch(BMI160Class::getAccelRate()) { + case BMI160_ACCEL_RATE_25_2HZ: + rate = 12.5; + break; + + case BMI160_ACCEL_RATE_25HZ: + rate = 25; + break; + + case BMI160_ACCEL_RATE_50HZ: + rate = 50; + break; + + case BMI160_ACCEL_RATE_100HZ: + rate = 100; + break; + + case BMI160_ACCEL_RATE_200HZ: + rate = 200; + break; + + case BMI160_ACCEL_RATE_400HZ: + rate = 400; + break; + + case BMI160_ACCEL_RATE_800HZ: + rate = 800; + break; + + case BMI160_ACCEL_RATE_1600HZ: + default: + rate = 1600; + break; + } + + return rate; } -void CurieIMUClass::setAccelerometerRate(int rate) +void CurieIMUClass::setAccelerometerRate(float rate) { - setAccelRate(rate); + BMI160AccelRate bmiRate; + + if (rate <= 12.5) { + bmiRate = BMI160_ACCEL_RATE_25_2HZ; + } else if (rate <= 25) { + bmiRate = BMI160_ACCEL_RATE_25HZ; + } else if (rate <= 50) { + bmiRate = BMI160_ACCEL_RATE_50HZ; + } else if (rate <= 100) { + bmiRate = BMI160_ACCEL_RATE_100HZ; + } else if (rate <= 200) { + bmiRate = BMI160_ACCEL_RATE_200HZ; + } else if (rate <= 400) { + bmiRate = BMI160_ACCEL_RATE_400HZ; + } else if (rate <= 800) { + bmiRate = BMI160_ACCEL_RATE_800HZ; + } else { + bmiRate = BMI160_ACCEL_RATE_1600HZ; + } + + setAccelRate(bmiRate); } int CurieIMUClass::getGyroRange() { - return getFullScaleGyroRange(); + int range; + + switch (getFullScaleGyroRange()) { + case BMI160_GYRO_RANGE_2000: + range = 2000; + break; + + case BMI160_GYRO_RANGE_1000: + range = 1000; + break; + + case BMI160_GYRO_RANGE_500: + range = 500; + break; + + case BMI160_GYRO_RANGE_250: + range = 250; + break; + + case BMI160_GYRO_RANGE_125: + default: + range = 125; + break; + } + + return range; } void CurieIMUClass::setGyroRange(int range) { - setFullScaleGyroRange(range); + BMI160GyroRange bmiRange; + + if (range >= 2000) { + bmiRange = BMI160_GYRO_RANGE_2000; + } else if (range >= 1000) { + bmiRange = BMI160_GYRO_RANGE_1000; + } else if (range >= 500) { + bmiRange = BMI160_GYRO_RANGE_500; + } else if (range >= 250) { + bmiRange = BMI160_GYRO_RANGE_250; + } else { + bmiRange = BMI160_GYRO_RANGE_125; + } + + setFullScaleGyroRange(bmiRange); } int CurieIMUClass::getAccelerometerRange() { - return getFullScaleAccelRange(); + int range; + + switch (getFullScaleAccelRange()) { + case BMI160_ACCEL_RANGE_2G: + range = 2; + break; + + case BMI160_ACCEL_RANGE_4G: + range = 4; + break; + + case BMI160_ACCEL_RANGE_8G: + range = 8; + break; + + case BMI160_ACCEL_RANGE_16G: + default: + range = 16; + break; + } + + return range; } void CurieIMUClass::setAccelerometerRange(int range) { - setFullScaleAccelRange(range); + BMI160AccelRange bmiRange; + + if (range <= 2) { + bmiRange = BMI160_ACCEL_RANGE_2G; + } else if (range <= 4) { + bmiRange = BMI160_ACCEL_RANGE_4G; + } else if (range <= 8) { + bmiRange = BMI160_ACCEL_RANGE_8G; + } else { + bmiRange = BMI160_ACCEL_RANGE_16G; + } + + setFullScaleAccelRange(bmiRange); } void CurieIMUClass::autoCalibrateGyroOffset() { BMI160Class::autoCalibrateGyroOffset(); + + setGyroOffsetEnabled(true); } void CurieIMUClass::autoCalibrateAccelerometerOffset(int axis, int target) @@ -120,16 +308,18 @@ void CurieIMUClass::autoCalibrateAccelerometerOffset(int axis, int target) default: break; } + + setAccelOffsetEnabled(true); } -void CurieIMUClass::enableGyroOffset(bool state) +void CurieIMUClass::noGyroOffset() { - setGyroOffsetEnabled(state); + setGyroOffsetEnabled(false); } -void CurieIMUClass::enableAccelerometerOffset(bool state) +void CurieIMUClass::noAccelerometerOffset() { - setAccelOffsetEnabled(state); + setAccelOffsetEnabled(false); } bool CurieIMUClass::gyroOffsetEnabled() @@ -177,6 +367,8 @@ void CurieIMUClass::setGyroOffset(int axis, int offset) } else if (axis == Z_AXIS) { setZGyroOffset(axis); } + + setGyroOffsetEnabled(true); } void CurieIMUClass::setAccelerometerOffset(int axis, int offset) @@ -188,9 +380,11 @@ void CurieIMUClass::setAccelerometerOffset(int axis, int offset) } else if (axis == Z_AXIS) { setZAccelOffset(axis); } + + setAccelOffsetEnabled(true); } -int CurieIMUClass::getDetectionThreshold(int feature) +float CurieIMUClass::getDetectionThreshold(int feature) { switch (feature) { case CURIE_IMU_FREEFALL: @@ -219,7 +413,7 @@ int CurieIMUClass::getDetectionThreshold(int feature) } } -void CurieIMUClass::setDetectionThreshold(int feature, int threshold) +void CurieIMUClass::setDetectionThreshold(int feature, float threshold) { switch (feature) { case CURIE_IMU_FREEFALL: @@ -253,7 +447,7 @@ void CurieIMUClass::setDetectionThreshold(int feature, int threshold) } } -int CurieIMUClass::getDetectionDuration(int feature) +float CurieIMUClass::getDetectionDuration(int feature) { switch (feature) { case CURIE_IMU_FREEFALL: @@ -286,7 +480,273 @@ int CurieIMUClass::getDetectionDuration(int feature) } } -void CurieIMUClass::setDetectionDuration(int feature, int value) +float CurieIMUClass::getFreefallDetectionThreshold() +{ + int bmiThreshold = BMI160Class::getFreefallDetectionThreshold(); + + return (bmiThreshold * 7.81) + 3.91; +} + +void CurieIMUClass::setFreefallDetectionThreshold(float threshold) +{ + int bmiThreshold = (threshold - 3.91) / 7.81; + + if (bmiThreshold < 0) { + bmiThreshold = 0; + } else if (bmiThreshold > 255) { + bmiThreshold = 255; + } + + BMI160Class::setFreefallDetectionThreshold(bmiThreshold); +} + +float CurieIMUClass::getShockDetectionThreshold() +{ + int bmiThreshold = BMI160Class::getShockDetectionThreshold(); + float step; + float min; + + switch (getAccelerometerRange()) { + case 2: + step = 7.81; + min = 3.91; + break; + + case 4: + step = 15.63; + min = 7.81; + break; + + case 8: + step = 31.25; + min = 15.63; + break; + + case 16: + default: + step = 62.50; + min = 31.25; + break; + } + + return (bmiThreshold * step) + min; +} + +void CurieIMUClass::setShockDetectionThreshold(float threshold) +{ + int bmiThreshold; + + switch (getAccelerometerRange()) { + case 2: + bmiThreshold = (threshold - 3.91) / 7.81; + break; + + case 4: + bmiThreshold = (threshold - 7.81) / 15.6; + break; + + case 8: + bmiThreshold = (threshold - 15.63) / 31.25; + break; + + case 16: + default: + bmiThreshold = (threshold - 31.25) / 62.50; + break; + } + + if (bmiThreshold < 0) { + bmiThreshold = 0; + } else if (bmiThreshold > 255) { + bmiThreshold = 255; + } + + BMI160Class::setShockDetectionThreshold(bmiThreshold); +} + +float CurieIMUClass::getMotionDetectionThreshold() +{ + int bmiThreshold = BMI160Class::getMotionDetectionThreshold(); + float step; + + switch (getAccelerometerRange()) { + case 2: + step = 3.91; + break; + + case 4: + step = 7.81; + break; + + case 8: + step = 15.63; + break; + + case 16: + default: + step = 31.25; + break; + } + + return (bmiThreshold * step); +} + +void CurieIMUClass::setMotionDetectionThreshold(float threshold) +{ + int bmiThreshold; + + switch (getAccelerometerRange()) { + case 2: + bmiThreshold = threshold / 3.91; + break; + + case 4: + bmiThreshold = threshold / 7.81; + break; + + case 8: + bmiThreshold = threshold / 15.63; + break; + + case 16: + default: + bmiThreshold = threshold / 31.25; + break; + } + + if (bmiThreshold < 0) { + bmiThreshold = 0; + } else if (bmiThreshold > 255) { + bmiThreshold = 255; + } + + BMI160Class::setMotionDetectionThreshold(bmiThreshold); +} + +float CurieIMUClass::getZeroMotionDetectionThreshold() +{ + int bmiThreshold = BMI160Class::getZeroMotionDetectionThreshold(); + float step; + + switch (getAccelerometerRange()) { + case 2: + step = 3.91; + break; + + case 4: + step = 7.81; + break; + + case 8: + step = 15.63; + break; + + case 16: + default: + step = 31.25; + break; + } + + return (bmiThreshold * step); +} + +void CurieIMUClass::setZeroMotionDetectionThreshold(float threshold) +{ + int bmiThreshold; + + switch (getAccelerometerRange()) { + case 2: + bmiThreshold = threshold / 3.91; + break; + + case 4: + bmiThreshold = threshold / 7.81; + break; + + case 8: + bmiThreshold = threshold / 15.63; + break; + + case 16: + default: + bmiThreshold = threshold / 31.25; + break; + } + + if (bmiThreshold < 0) { + bmiThreshold = 0; + } else if (bmiThreshold > 255) { + bmiThreshold = 255; + } + + BMI160Class::setZeroMotionDetectionThreshold(bmiThreshold); +} + +float CurieIMUClass::getTapDetectionThreshold() +{ + int bmiThreshold = BMI160Class::getTapDetectionThreshold(); + float step; + float min; + + switch (getAccelerometerRange()) { + case 2: + step = 62.5; + min = 31.25; + break; + + case 4: + step = 125.0; + min = 62.5; + break; + + case 8: + step = 250.0; + min = 125.0; + break; + + case 16: + default: + step = 500.0; + min = 250.0; + break; + } + + return (bmiThreshold * step) + min; +} + +void CurieIMUClass::setTapDetectionThreshold(float threshold) +{ + int bmiThreshold; + + switch (getAccelerometerRange()) { + case 2: + bmiThreshold = (threshold - 31.25) / 62.5; + break; + + case 4: + bmiThreshold = (threshold - 62.5) / 125.0; + break; + + case 8: + bmiThreshold = (threshold - 125.0) / 250.0; + break; + + case 16: + default: + bmiThreshold = (threshold - 2500) / 500.0; + break; + } + + if (bmiThreshold < 0) { + bmiThreshold = 0; + } else if (bmiThreshold > 255) { + bmiThreshold = 255; + } + + BMI160Class::setTapDetectionThreshold(bmiThreshold); +} + +void CurieIMUClass::setDetectionDuration(int feature, float value) { switch (feature) { case CURIE_IMU_FREEFALL: @@ -326,6 +786,617 @@ void CurieIMUClass::setDetectionDuration(int feature, int value) } } +float CurieIMUClass::getFreefallDetectionDuration() +{ + int bmiDuration = BMI160Class::getFreefallDetectionDuration(); + + return ((bmiDuration + 1) * 2.5); +} + +void CurieIMUClass::setFreefallDetectionDuration(float duration) +{ + int bmiDuration = (duration - 2.5) / 2.5; + + if (bmiDuration < 0) { + bmiDuration = 0; + } else if (bmiDuration > 255) { + bmiDuration = 255; + } + + BMI160Class::setFreefallDetectionDuration(bmiDuration); +} + +int CurieIMUClass::getShockDetectionDuration() +{ + int duration; + + switch (BMI160Class::getShockDetectionDuration()) { + case BMI160_TAP_SHOCK_DURATION_50MS: + duration = 50; + break; + + case BMI160_TAP_SHOCK_DURATION_75MS: + default: + duration = 75; + break; + } + + return duration; +} +void CurieIMUClass::setShockDetectionDuration(int duration) +{ + BMI160TapShockDuration bmiDuration; + + if (duration <= 50) { + bmiDuration = BMI160_TAP_SHOCK_DURATION_50MS; + } else { + bmiDuration = BMI160_TAP_SHOCK_DURATION_75MS; + } + + BMI160Class::setShockDetectionDuration(bmiDuration); +} + +float CurieIMUClass::getMotionDetectionDuration() +{ + int bmiDuration = BMI160Class::getMotionDetectionDuration(); + + return (bmiDuration / getAccelerometerRate()); + + +} +void CurieIMUClass::setMotionDetectionDuration(float duration) +{ + int bmiDuration = (duration * getAccelerometerRate()); + + if (bmiDuration < 1) { + bmiDuration = 1; + } else if (bmiDuration > 4) { + bmiDuration = 4; + } + + BMI160Class::setMotionDetectionDuration(bmiDuration); +} + +float CurieIMUClass::getZeroMotionDetectionDuration() +{ + float duration; + + switch (BMI160Class::getZeroMotionDetectionDuration()) { + case BMI160_ZERO_MOTION_DURATION_1_28S: + duration = 1.28; + break; + + case BMI160_ZERO_MOTION_DURATION_2_56S: + duration = 2.56; + break; + + case BMI160_ZERO_MOTION_DURATION_3_84S: + duration = 3.84; + break; + + case BMI160_ZERO_MOTION_DURATION_5_12S: + duration = 5.12; + break; + + case BMI160_ZERO_MOTION_DURATION_6_40S: + duration = 6.40; + break; + + case BMI160_ZERO_MOTION_DURATION_7_68S: + duration = 7.68; + break; + + case BMI160_ZERO_MOTION_DURATION_8_96S: + duration = 8.96; + break; + + case BMI160_ZERO_MOTION_DURATION_10_24S: + duration = 10.24; + break; + + case BMI160_ZERO_MOTION_DURATION_11_52S: + duration = 11.52; + break; + + case BMI160_ZERO_MOTION_DURATION_12_80S: + duration = 12.80; + break; + + case BMI160_ZERO_MOTION_DURATION_14_08S: + duration = 14.08; + break; + + case BMI160_ZERO_MOTION_DURATION_15_36S: + duration = 15.36; + break; + + case BMI160_ZERO_MOTION_DURATION_16_64S: + duration = 16.64; + break; + + case BMI160_ZERO_MOTION_DURATION_17_92S: + duration = 17.92; + break; + + case BMI160_ZERO_MOTION_DURATION_19_20S: + duration = 19.20; + break; + + case BMI160_ZERO_MOTION_DURATION_20_48S: + duration = 20.48; + break; + + case BMI160_ZERO_MOTION_DURATION_25_60S: + duration = 25.60; + break; + + case BMI160_ZERO_MOTION_DURATION_30_72S: + duration = 30.72; + break; + + case BMI160_ZERO_MOTION_DURATION_35_84S: + duration = 35.84; + break; + + case BMI160_ZERO_MOTION_DURATION_40_96S: + duration = 40.96; + break; + + case BMI160_ZERO_MOTION_DURATION_46_08S: + duration = 46.08; + break; + + case BMI160_ZERO_MOTION_DURATION_51_20S: + duration = 51.20; + break; + + case BMI160_ZERO_MOTION_DURATION_56_32S: + duration = 56.32; + break; + + case BMI160_ZERO_MOTION_DURATION_61_44S: + duration = 61.44; + break; + + case BMI160_ZERO_MOTION_DURATION_66_56S: + duration = 66.56; + break; + + case BMI160_ZERO_MOTION_DURATION_71_68S: + duration = 71.68; + break; + + case BMI160_ZERO_MOTION_DURATION_76_80S: + duration = 76.80; + break; + + case BMI160_ZERO_MOTION_DURATION_81_92S: + duration = 81.92; + break; + + case BMI160_ZERO_MOTION_DURATION_87_04S: + duration = 87.04; + break; + + case BMI160_ZERO_MOTION_DURATION_92_16S: + duration = 92.16; + break; + + case BMI160_ZERO_MOTION_DURATION_97_28S: + duration = 97.28; + break; + + case BMI160_ZERO_MOTION_DURATION_102_40S: + duration = 102.40; + break; + + case BMI160_ZERO_MOTION_DURATION_112_64S: + duration = 112.64; + break; + + case BMI160_ZERO_MOTION_DURATION_122_88S: + duration = 122.88; + break; + + case BMI160_ZERO_MOTION_DURATION_133_12S: + duration = 133.12; + break; + + case BMI160_ZERO_MOTION_DURATION_143_36S: + duration = 143.36; + break; + + case BMI160_ZERO_MOTION_DURATION_153_60S: + duration = 153.60; + break; + + case BMI160_ZERO_MOTION_DURATION_163_84S: + duration = 163.84; + break; + + case BMI160_ZERO_MOTION_DURATION_174_08S: + duration = 174.08; + break; + + case BMI160_ZERO_MOTION_DURATION_184_32S: + duration = 184.32; + break; + + case BMI160_ZERO_MOTION_DURATION_194_56S: + duration = 194.56; + break; + + case BMI160_ZERO_MOTION_DURATION_204_80S: + duration = 204.80; + break; + + case BMI160_ZERO_MOTION_DURATION_215_04S: + duration = 215.04; + break; + + case BMI160_ZERO_MOTION_DURATION_225_28S: + duration = 225.28; + break; + + case BMI160_ZERO_MOTION_DURATION_235_52S: + duration = 235.52; + break; + + case BMI160_ZERO_MOTION_DURATION_245_76S: + duration = 245.76; + break; + + case BMI160_ZERO_MOTION_DURATION_256_00S: + duration = 256.00; + break; + + case BMI160_ZERO_MOTION_DURATION_266_24S: + duration = 266.24; + break; + + case BMI160_ZERO_MOTION_DURATION_276_48S: + duration = 276.48; + break; + + case BMI160_ZERO_MOTION_DURATION_286_72S: + duration = 286.72; + break; + + case BMI160_ZERO_MOTION_DURATION_296_96S: + duration = 296.96; + break; + + case BMI160_ZERO_MOTION_DURATION_307_20S: + duration = 307.20; + break; + + case BMI160_ZERO_MOTION_DURATION_317_44S: + duration = 317.44; + break; + + case BMI160_ZERO_MOTION_DURATION_327_68S: + duration = 327.68; + break; + + case BMI160_ZERO_MOTION_DURATION_337_92S: + duration = 337.92; + break; + + case BMI160_ZERO_MOTION_DURATION_348_16S: + duration = 348.16; + break; + + case BMI160_ZERO_MOTION_DURATION_358_40S: + duration = 358.40; + break; + + case BMI160_ZERO_MOTION_DURATION_368_64S: + duration = 368.64; + break; + + case BMI160_ZERO_MOTION_DURATION_378_88S: + duration = 378.88; + break; + + case BMI160_ZERO_MOTION_DURATION_389_12S: + duration = 389.12; + break; + + case BMI160_ZERO_MOTION_DURATION_399_36S: + duration = 399.36; + break; + + case BMI160_ZERO_MOTION_DURATION_409_60S: + duration = 409.60; + break; + + case BMI160_ZERO_MOTION_DURATION_419_84S: + duration = 419.84; + break; + + case BMI160_ZERO_MOTION_DURATION_430_08S: + default: + duration = 430.08; + break; + } + + return duration; +} +void CurieIMUClass::setZeroMotionDetectionDuration(float duration) +{ + BMI160ZeroMotionDuration bmiDuration; + + if (duration <= 1.28) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_1_28S; + } else if (duration <= 2.56) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_2_56S; + } else if (duration <= 3.84) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_3_84S; + } else if (duration <= 5.12) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_5_12S; + } else if (duration <= 6.40) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_6_40S; + } else if (duration <= 7.68) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_7_68S; + } else if (duration <= 8.96) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_8_96S; + } else if (duration <= 10.24) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_10_24S; + } else if (duration <= 11.52) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_11_52S; + } else if (duration <= 12.80) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_12_80S; + } else if (duration <= 14.08) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_14_08S; + } else if (duration <= 15.36) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_15_36S; + } else if (duration <= 16.64) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_16_64S; + } else if (duration <= 17.92) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_17_92S; + } else if (duration <= 19.20) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_19_20S; + } else if (duration <= 20.48) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_20_48S; + } else if (duration <= 25.60) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_25_60S; + } else if (duration <= 30.72) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_30_72S; + } else if (duration <= 35.84) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_35_84S; + } else if (duration <= 40.96) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_40_96S; + } else if (duration <= 46.08) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_46_08S; + } else if (duration <= 51.20) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_51_20S; + } else if (duration <= 56.32) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_56_32S; + } else if (duration <= 61.44) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_61_44S; + } else if (duration <= 66.56) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_66_56S; + } else if (duration <= 71.68) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_71_68S; + } else if (duration <= 76.80) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_76_80S; + } else if (duration <= 81.92) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_81_92S; + } else if (duration <= 87.04) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_87_04S; + } else if (duration <= 92.16) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_92_16S; + } else if (duration <= 97.28) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_97_28S; + } else if (duration <= 102.40) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_102_40S; + } else if (duration <= 112.64) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_112_64S; + } else if (duration <= 122.88) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_122_88S; + } else if (duration <= 133.12) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_133_12S; + } else if (duration <= 143.36) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_143_36S; + } else if (duration <= 153.60) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_153_60S; + } else if (duration <= 163.84) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_163_84S; + } else if (duration <= 174.08) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_174_08S; + } else if (duration <= 184.32) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_184_32S; + } else if (duration <= 194.56) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_194_56S; + } else if (duration <= 204.80) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_204_80S; + } else if (duration <= 215.04) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_215_04S; + } else if (duration <= 225.28) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_225_28S; + } else if (duration <= 235.52) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_235_52S; + } else if (duration <= 245.76) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_245_76S; + } else if (duration <= 256.00) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_256_00S; + } else if (duration <= 266.24) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_266_24S; + } else if (duration <= 276.48) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_276_48S; + } else if (duration <= 286.72) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_286_72S; + } else if (duration <= 296.96) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_296_96S; + } else if (duration <= 307.20) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_307_20S; + } else if (duration <= 317.44) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_317_44S; + } else if (duration <= 327.68) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_327_68S; + } else if (duration <= 337.92) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_337_92S; + } else if (duration <= 348.16) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_348_16S; + } else if (duration <= 358.40) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_358_40S; + } else if (duration <= 368.64) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_368_64S; + } else if (duration <= 378.88) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_378_88S; + } else if (duration <= 389.12) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_389_12S; + } else if (duration <= 399.36) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_399_36S; + } else if (duration <= 409.60) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_409_60S; + } else if (duration <= 419.84) { + bmiDuration = BMI160_ZERO_MOTION_DURATION_419_84S; + } else { + bmiDuration = BMI160_ZERO_MOTION_DURATION_430_08S; + } + + BMI160Class::setZeroMotionDetectionDuration(bmiDuration); +} + +int CurieIMUClass::getTapShockDuration() +{ + int duration; + + switch (BMI160Class::getTapShockDuration()) { + case BMI160_TAP_SHOCK_DURATION_50MS: + duration = 50; + break; + + case BMI160_TAP_SHOCK_DURATION_75MS: + default: + duration = 75; + break; + } + + return duration; +} + +void CurieIMUClass::setTapShockDuration(int duration) +{ + BMI160TapShockDuration bmiDuration; + + if (duration <= 50) { + bmiDuration = BMI160_TAP_SHOCK_DURATION_50MS; + } else { + bmiDuration = BMI160_TAP_SHOCK_DURATION_75MS; + } + + BMI160Class::setTapShockDuration(bmiDuration); +} + +int CurieIMUClass::getTapQuietDuration() +{ + int duration; + + switch (BMI160Class::getTapQuietDuration()) { + case BMI160_TAP_QUIET_DURATION_30MS: + duration = 30; + break; + + case BMI160_TAP_QUIET_DURATION_20MS: + default: + duration = 20; + break; + } + + return duration; +} + +void CurieIMUClass::setTapQuietDuration(int duration) +{ + BMI160TapQuietDuration bmiDuration; + + if (duration >= 30) { + bmiDuration = BMI160_TAP_QUIET_DURATION_30MS; + } else { + bmiDuration = BMI160_TAP_QUIET_DURATION_20MS; + } + + BMI160Class::setTapQuietDuration(bmiDuration); +} + +int CurieIMUClass::getDoubleTapDetectionDuration() +{ + int duration; + + switch (BMI160Class::getDoubleTapDetectionDuration()) { + case BMI160_DOUBLE_TAP_DURATION_50MS: + duration = 50; + break; + + case BMI160_DOUBLE_TAP_DURATION_100MS: + duration = 100; + break; + + case BMI160_DOUBLE_TAP_DURATION_150MS: + duration = 150; + break; + + case BMI160_DOUBLE_TAP_DURATION_200MS: + duration = 200; + break; + + case BMI160_DOUBLE_TAP_DURATION_250MS: + duration = 250; + break; + + case BMI160_DOUBLE_TAP_DURATION_375MS: + duration = 375; + break; + + case BMI160_DOUBLE_TAP_DURATION_500MS: + duration = 500; + break; + + case BMI160_DOUBLE_TAP_DURATION_700MS: + default: + duration = 700; + break; + } + + return duration; +} +void CurieIMUClass::setDoubleTapDetectionDuration(int duration) +{ + BMI160DoubleTapDuration bmiDuration; + + if (duration <= 50) { + bmiDuration = BMI160_DOUBLE_TAP_DURATION_50MS; + } else if (duration <= 100) { + bmiDuration = BMI160_DOUBLE_TAP_DURATION_100MS; + } else if (duration <= 150) { + bmiDuration = BMI160_DOUBLE_TAP_DURATION_150MS; + } else if (duration <= 200) { + bmiDuration = BMI160_DOUBLE_TAP_DURATION_200MS; + } else if (duration <= 250) { + bmiDuration = BMI160_DOUBLE_TAP_DURATION_250MS; + } else if (duration <= 375) { + bmiDuration = BMI160_DOUBLE_TAP_DURATION_375MS; + } else if (duration <= 500) { + bmiDuration = BMI160_DOUBLE_TAP_DURATION_500MS; + } else { + bmiDuration = BMI160_DOUBLE_TAP_DURATION_700MS; + } + + BMI160Class::setDoubleTapDetectionDuration(bmiDuration); +} + +void CurieIMUClass::interrupts(int feature) +{ + enableInterrupt(feature, true); +} + +void CurieIMUClass::noInterrupts(int feature) +{ + enableInterrupt(feature, false); +} + void CurieIMUClass::enableInterrupt(int feature, bool enabled) { switch (feature) { @@ -372,7 +1443,7 @@ void CurieIMUClass::enableInterrupt(int feature, bool enabled) } } -bool CurieIMUClass::interruptEnabled(int feature) +bool CurieIMUClass::interruptsEnabled(int feature) { switch (feature) { case CURIE_IMU_FREEFALL: diff --git a/libraries/CurieIMU/src/CurieIMU.h b/libraries/CurieIMU/src/CurieIMU.h index 86d672aa..f1c6b71f 100644 --- a/libraries/CurieIMU/src/CurieIMU.h +++ b/libraries/CurieIMU/src/CurieIMU.h @@ -69,59 +69,6 @@ typedef enum { CURIE_IMU_DATA_READY, } CurieIMUFeature; -/** - * Accelerometer Sensitivity Range options - * @see setAccelerometerRange() - */ -typedef enum { - CURIE_IMU_ACCELEROMETER_RANGE_2G = BMI160_ACCEL_RANGE_2G, - CURIE_IMU_ACCELEROMETER_RANGE_4G = BMI160_ACCEL_RANGE_4G, - CURIE_IMU_ACCELEROMETER_RANGE_8G = BMI160_ACCEL_RANGE_8G, - CURIE_IMU_ACCELEROMETER_RANGE_16G = BMI160_ACCEL_RANGE_16G -} CurieIMUAccelerometerRange; - -/** - * Gyroscope Sensitivity Range options - * @see setGyroRange() - */ -typedef enum { - CURIE_IMU_GYRO_RANGE_2000 = BMI160_GYRO_RANGE_2000, - CURIE_IMU_GYRO_RANGE_1000 = BMI160_GYRO_RANGE_1000, - CURIE_IMU_GYRO_RANGE_500 = BMI160_GYRO_RANGE_500, - CURIE_IMU_GYRO_RANGE_250 = BMI160_GYRO_RANGE_250, - CURIE_IMU_GYRO_RANGE_125 = BMI160_GYRO_RANGE_125 -} CurieIMUGyroRange; - -/** - * Accelerometer Output Data Rate options - * @see setAccelerometerRate() - */ -typedef enum { - CURIE_IMU_ACCELEROMETER_RATE_25_2HZ = BMI160_ACCEL_RATE_25_2HZ, - CURIE_IMU_ACCELEROMETER_RATE_25HZ = BMI160_ACCEL_RATE_25HZ, - CURIE_IMU_ACCELEROMETER_RATE_50HZ = BMI160_ACCEL_RATE_50HZ, - CURIE_IMU_ACCELEROMETER_RATE_100HZ = BMI160_ACCEL_RATE_100HZ, - CURIE_IMU_ACCELEROMETER_RATE_200HZ = BMI160_ACCEL_RATE_200HZ, - CURIE_IMU_ACCELEROMETER_RATE_400HZ = BMI160_ACCEL_RATE_400HZ, - CURIE_IMU_ACCELEROMETER_RATE_800HZ = BMI160_ACCEL_RATE_800HZ, - CURIE_IMU_ACCELEROMETER_RATE_1600HZ = BMI160_ACCEL_RATE_1600HZ -} CurieIMUAccelRate; - -/** - * Gyroscope Output Data Rate options - * @see setGyroRate() - */ -typedef enum { - CURIE_IMU_GYRO_RATE_25HZ = BMI160_GYRO_RATE_25HZ, - CURIE_IMU_GYRO_RATE_50HZ = BMI160_GYRO_RATE_50HZ, - CURIE_IMU_GYRO_RATE_100HZ = BMI160_GYRO_RATE_100HZ, - CURIE_IMU_GYRO_RATE_200HZ = BMI160_GYRO_RATE_200HZ, - CURIE_IMU_GYRO_RATE_400HZ = BMI160_GYRO_RATE_400HZ, - CURIE_IMU_GYRO_RATE_800HZ = BMI160_GYRO_RATE_800HZ, - CURIE_IMU_GYRO_RATE_1600HZ = BMI160_GYRO_RATE_1600HZ, - CURIE_IMU_GYRO_RATE_3200HZ = BMI160_GYRO_RATE_3200HZ -} CurieIMUGyroRate; - /** * Step Detection Mode options * @see setStepDetectionMode() @@ -133,110 +80,6 @@ typedef enum { CURIE_IMU_STEP_MODE_UNKNOWN = BMI160_STEP_MODE_UNKNOWN } CurieIMUStepMode; -/** - * Tap Detection Shock Duration options - * @see setDetectionThreshold(CURIE_IMU_TAP, ...) - */ -typedef enum { - CURIE_IMU_TAP_SHOCK_DURATION_50MS = BMI160_TAP_SHOCK_DURATION_50MS, - CURIE_IMU_TAP_SHOCK_DURATION_75MS = BMI160_TAP_SHOCK_DURATION_75MS -} CurieIMUTapShockDuration; - -/** - * Tap Detection Quiet Duration options - * @see setDetectionThreshold(CURIE_IMU_TAP_QUIET, ...) - */ -typedef enum { - CURIE_IMU_TAP_QUIET_DURATION_30MS = BMI160_TAP_QUIET_DURATION_30MS, - CURIE_IMU_TAP_QUIET_DURATION_20MS = BMI160_TAP_QUIET_DURATION_20MS -} CurieIMUTapQuietDuration; - -/** - * Double-Tap Detection Duration options - * @see setDetectionThreshold(CURIE_IMU_DOUBLE_TAP, ...) - */ -typedef enum { - CURIE_IMU_DOUBLE_TAP_DURATION_50MS = BMI160_DOUBLE_TAP_DURATION_50MS, - CURIE_IMU_DOUBLE_TAP_DURATION_100MS = BMI160_DOUBLE_TAP_DURATION_100MS, - CURIE_IMU_DOUBLE_TAP_DURATION_150MS = BMI160_DOUBLE_TAP_DURATION_150MS, - CURIE_IMU_DOUBLE_TAP_DURATION_200MS = BMI160_DOUBLE_TAP_DURATION_200MS, - CURIE_IMU_DOUBLE_TAP_DURATION_250MS = BMI160_DOUBLE_TAP_DURATION_250MS, - CURIE_IMU_DOUBLE_TAP_DURATION_375MS = BMI160_DOUBLE_TAP_DURATION_375MS, - CURIE_IMU_DOUBLE_TAP_DURATION_500MS = BMI160_DOUBLE_TAP_DURATION_500MS, - CURIE_IMU_DOUBLE_TAP_DURATION_700MS = BMI160_DOUBLE_TAP_DURATION_700MS -} CurieIMUDoubleTapDuration; - -/** - * Zero-Motion Detection Duration options - * @see setDetectionThreshold(CURIE_IMU_ZERO_MOTION, ...) - */ -typedef enum { - CURIE_IMU_ZERO_MOTION_DURATION_1_28S = BMI160_ZERO_MOTION_DURATION_1_28S, - CURIE_IMU_ZERO_MOTION_DURATION_2_56S = BMI160_ZERO_MOTION_DURATION_2_56S, - CURIE_IMU_ZERO_MOTION_DURATION_3_84S = BMI160_ZERO_MOTION_DURATION_3_84S, - CURIE_IMU_ZERO_MOTION_DURATION_5_12S = BMI160_ZERO_MOTION_DURATION_5_12S, - CURIE_IMU_ZERO_MOTION_DURATION_6_40S = BMI160_ZERO_MOTION_DURATION_6_40S, - CURIE_IMU_ZERO_MOTION_DURATION_7_68S = BMI160_ZERO_MOTION_DURATION_7_68S, - CURIE_IMU_ZERO_MOTION_DURATION_8_96S = BMI160_ZERO_MOTION_DURATION_8_96S, - CURIE_IMU_ZERO_MOTION_DURATION_10_24S = BMI160_ZERO_MOTION_DURATION_10_24S, - CURIE_IMU_ZERO_MOTION_DURATION_11_52S = BMI160_ZERO_MOTION_DURATION_11_52S, - CURIE_IMU_ZERO_MOTION_DURATION_12_80S = BMI160_ZERO_MOTION_DURATION_12_80S, - CURIE_IMU_ZERO_MOTION_DURATION_14_08S = BMI160_ZERO_MOTION_DURATION_14_08S, - CURIE_IMU_ZERO_MOTION_DURATION_15_36S = BMI160_ZERO_MOTION_DURATION_15_36S, - CURIE_IMU_ZERO_MOTION_DURATION_16_64S = BMI160_ZERO_MOTION_DURATION_16_64S, - CURIE_IMU_ZERO_MOTION_DURATION_17_92S = BMI160_ZERO_MOTION_DURATION_17_92S, - CURIE_IMU_ZERO_MOTION_DURATION_19_20S = BMI160_ZERO_MOTION_DURATION_19_20S, - CURIE_IMU_ZERO_MOTION_DURATION_20_48S = BMI160_ZERO_MOTION_DURATION_20_48S, - CURIE_IMU_ZERO_MOTION_DURATION_25_60S = BMI160_ZERO_MOTION_DURATION_25_60S, - CURIE_IMU_ZERO_MOTION_DURATION_30_72S = BMI160_ZERO_MOTION_DURATION_30_72S, - CURIE_IMU_ZERO_MOTION_DURATION_35_84S = BMI160_ZERO_MOTION_DURATION_35_84S, - CURIE_IMU_ZERO_MOTION_DURATION_40_96S = BMI160_ZERO_MOTION_DURATION_40_96S, - CURIE_IMU_ZERO_MOTION_DURATION_46_08S = BMI160_ZERO_MOTION_DURATION_46_08S, - CURIE_IMU_ZERO_MOTION_DURATION_51_20S = BMI160_ZERO_MOTION_DURATION_51_20S, - CURIE_IMU_ZERO_MOTION_DURATION_56_32S = BMI160_ZERO_MOTION_DURATION_56_32S, - CURIE_IMU_ZERO_MOTION_DURATION_61_44S = BMI160_ZERO_MOTION_DURATION_61_44S, - CURIE_IMU_ZERO_MOTION_DURATION_66_56S = BMI160_ZERO_MOTION_DURATION_66_56S, - CURIE_IMU_ZERO_MOTION_DURATION_71_68S = BMI160_ZERO_MOTION_DURATION_71_68S, - CURIE_IMU_ZERO_MOTION_DURATION_76_80S = BMI160_ZERO_MOTION_DURATION_76_80S, - CURIE_IMU_ZERO_MOTION_DURATION_81_92S = BMI160_ZERO_MOTION_DURATION_81_92S, - CURIE_IMU_ZERO_MOTION_DURATION_87_04S = BMI160_ZERO_MOTION_DURATION_87_04S, - CURIE_IMU_ZERO_MOTION_DURATION_92_16S = BMI160_ZERO_MOTION_DURATION_92_16S, - CURIE_IMU_ZERO_MOTION_DURATION_97_28S = BMI160_ZERO_MOTION_DURATION_97_28S, - CURIE_IMU_ZERO_MOTION_DURATION_102_40S = BMI160_ZERO_MOTION_DURATION_102_40S, - CURIE_IMU_ZERO_MOTION_DURATION_112_64S = BMI160_ZERO_MOTION_DURATION_112_64S, - CURIE_IMU_ZERO_MOTION_DURATION_122_88S = BMI160_ZERO_MOTION_DURATION_122_88S, - CURIE_IMU_ZERO_MOTION_DURATION_133_12S = BMI160_ZERO_MOTION_DURATION_133_12S, - CURIE_IMU_ZERO_MOTION_DURATION_143_36S = BMI160_ZERO_MOTION_DURATION_143_36S, - CURIE_IMU_ZERO_MOTION_DURATION_153_60S = BMI160_ZERO_MOTION_DURATION_153_60S, - CURIE_IMU_ZERO_MOTION_DURATION_163_84S = BMI160_ZERO_MOTION_DURATION_163_84S, - CURIE_IMU_ZERO_MOTION_DURATION_174_08S = BMI160_ZERO_MOTION_DURATION_174_08S, - CURIE_IMU_ZERO_MOTION_DURATION_184_32S = BMI160_ZERO_MOTION_DURATION_184_32S, - CURIE_IMU_ZERO_MOTION_DURATION_194_56S = BMI160_ZERO_MOTION_DURATION_194_56S, - CURIE_IMU_ZERO_MOTION_DURATION_204_80S = BMI160_ZERO_MOTION_DURATION_204_80S, - CURIE_IMU_ZERO_MOTION_DURATION_215_04S = BMI160_ZERO_MOTION_DURATION_215_04S, - CURIE_IMU_ZERO_MOTION_DURATION_225_28S = BMI160_ZERO_MOTION_DURATION_225_28S, - CURIE_IMU_ZERO_MOTION_DURATION_235_52S = BMI160_ZERO_MOTION_DURATION_235_52S, - CURIE_IMU_ZERO_MOTION_DURATION_245_76S = BMI160_ZERO_MOTION_DURATION_245_76S, - CURIE_IMU_ZERO_MOTION_DURATION_256_00S = BMI160_ZERO_MOTION_DURATION_256_00S, - CURIE_IMU_ZERO_MOTION_DURATION_266_24S = BMI160_ZERO_MOTION_DURATION_266_24S, - CURIE_IMU_ZERO_MOTION_DURATION_276_48S = BMI160_ZERO_MOTION_DURATION_276_48S, - CURIE_IMU_ZERO_MOTION_DURATION_286_72S = BMI160_ZERO_MOTION_DURATION_286_72S, - CURIE_IMU_ZERO_MOTION_DURATION_296_96S = BMI160_ZERO_MOTION_DURATION_296_96S, - CURIE_IMU_ZERO_MOTION_DURATION_307_20S = BMI160_ZERO_MOTION_DURATION_307_20S, - CURIE_IMU_ZERO_MOTION_DURATION_317_44S = BMI160_ZERO_MOTION_DURATION_317_44S, - CURIE_IMU_ZERO_MOTION_DURATION_327_68S = BMI160_ZERO_MOTION_DURATION_327_68S, - CURIE_IMU_ZERO_MOTION_DURATION_337_92S = BMI160_ZERO_MOTION_DURATION_337_92S, - CURIE_IMU_ZERO_MOTION_DURATION_348_16S = BMI160_ZERO_MOTION_DURATION_348_16S, - CURIE_IMU_ZERO_MOTION_DURATION_358_40S = BMI160_ZERO_MOTION_DURATION_358_40S, - CURIE_IMU_ZERO_MOTION_DURATION_368_64S = BMI160_ZERO_MOTION_DURATION_368_64S, - CURIE_IMU_ZERO_MOTION_DURATION_378_88S = BMI160_ZERO_MOTION_DURATION_378_88S, - CURIE_IMU_ZERO_MOTION_DURATION_389_12S = BMI160_ZERO_MOTION_DURATION_389_12S, - CURIE_IMU_ZERO_MOTION_DURATION_399_36S = BMI160_ZERO_MOTION_DURATION_399_36S, - CURIE_IMU_ZERO_MOTION_DURATION_409_60S = BMI160_ZERO_MOTION_DURATION_409_60S, - CURIE_IMU_ZERO_MOTION_DURATION_419_84S = BMI160_ZERO_MOTION_DURATION_419_84S, - CURIE_IMU_ZERO_MOTION_DURATION_430_08S = BMI160_ZERO_MOTION_DURATION_430_08S -} CurieIMUZeroMotionDuration; - /* Note that this CurieIMUClass class inherits methods from the BMI160Class which * is defined in BMI160.h. BMI160Class provides methods for configuring and * accessing features of the BMI160 IMU device. This CurieIMUClass extends that @@ -253,22 +96,27 @@ class CurieIMUClass : public BMI160Class { public: bool begin(void); + // supported values: 25, 50, 100, 200, 400, 800, 1600, 3200 (Hz) int getGyroRate(); void setGyroRate(int rate); - int getAccelerometerRate(); - void setAccelerometerRate(int rate); + // supported values: 12.5, 25, 50, 100, 200, 400, 800, 1600 (Hz) + float getAccelerometerRate(); + void setAccelerometerRate(float rate); + // supported values: 125, 250, 500, 1000, 2000 (degrees/second) int getGyroRange(); void setGyroRange(int range); + + // supported values: 2, 4, 8, 16 (G) int getAccelerometerRange(); void setAccelerometerRange(int range); void autoCalibrateGyroOffset(); void autoCalibrateAccelerometerOffset(int axis, int target); - void enableGyroOffset(bool state); - void enableAccelerometerOffset(bool state); + void noGyroOffset(); + void noAccelerometerOffset(); bool gyroOffsetEnabled(); bool accelerometerOffsetEnabled(); @@ -278,14 +126,56 @@ class CurieIMUClass : public BMI160Class { void setGyroOffset(int axis, int offset); void setAccelerometerOffset(int axis, int offset); - int getDetectionThreshold(int feature); - void setDetectionThreshold(int feature, int threshold); - - int getDetectionDuration(int feature); - void setDetectionDuration(int feature, int value); //value (bool) duration or samples - - void enableInterrupt(int feature, bool enabled); - bool interruptEnabled(int feature); + // supported values: + // CURIE_IMU_FREEFALL: 3.91 to 1995.46 (mg), in steps of 7.81 mg + // CURIE_IMU_SHOCK: + // 2G: 3.91 to 1995.46 (mg), in steps of 7.81 mg + // 4G: 7.81 to 3993.46 (mg), in steps of 15.63 mg + // 8G: 15.63 to 7984.38 (mg), in steps of 31.25 mg + // 16G: 31.25 to 15968.75 (mg), in steps of 62.50 mg + // CURIE_IMU_MOTION: + // 2G: 0 to 997.05 (mg), in steps of 3.91 mg + // 4G: 0 to 1991.55 (mg), in steps of 7.81 mg + // 8G: 0 to 3985.65 (mg), in steps of 15.63 mg + // 16G: 0 to 7968.75 (mg), in steps of 31.25 mg + // CURIE_IMU_ZERO_MOTION: + // 2G: 0 to 997.05 (mg), in steps of 3.91 mg + // 4G: 0 to 1991.55 (mg), in steps of 7.81 mg + // 8G: 0 to 3985.65 (mg), in steps of 15.63 mg + // 16G: 0 to 7968.75 (mg), in steps of 31.25 mg + // CURIE_IMU_TAP: + // 2G: 31.25 to 7968.75 (mg), in steps of 62.5 mg + // 4G: 62.50 to 31937.50 (mg), in steps of 125.0 mg + // 8G: 125.0 to 63875.00 (mg), in steps of 250.0 mg + // 16G: 250.0 to 127750.00 (mg), in steps of 500 mg + float getDetectionThreshold(int feature); + void setDetectionThreshold(int feature, float threshold); + + // supported values: + // CURIE_IMU_FREEFALL: 2.5 to 637.5 (ms), in steps of 2.5 ms + // CURIE_IMU_SHOCK: 50, 75 (ms) + // CURIE_IMU_MOTION: [1 - 4] / getAccelerometerRate() S + // CURIE_IMU_ZERO_MOTION: 1.28, 2.56, 3.84, 5.12, 6.40, 7.68, 8.96, + // 10.24, 11.52, 12.80, 14.08, 15.36, 16.64, + // 17.92, 19.20, 20.48, 25.60, 30.72, 35.84, + // 40.96, 46.08, 51.20, 56.32, 61.44, 66.56, + // 71.68, 76.80, 81.92, 87.04, 92.16, 97.28, + // 102.40, 112.64, 122.88, 133.12, 143.36, + // 153.60, 163.84, 174.08, 184.32, 194.56, + // 204.80, 215.04, 225.28, 235.52, 245.76, + // 256.00, 266.24, 276.48, 286.72, 296.96, + // 307.20, 317.44, 327.68, 337.92, 348.16, + // 358.40, 368.64, 378.88, 389.12, 399.36, + // 409.60, 419.84, 430.08 S + // CURIE_IMU_DOUBLE_TAP: 50, 100, 150, 200, 250, 275, 500, 700 ms + // CURIE_IMU_TAP_SHOCK: 50, 75 ms + // CURIE_IMU_TAP_QUIET: 20, 30 ms + float getDetectionDuration(int feature); + void setDetectionDuration(int feature, float value); //value duration + + void interrupts(int feature); + void noInterrupts(int feature); + bool interruptsEnabled(int feature); int getInterruptStatus(int feature); @@ -311,6 +201,34 @@ class CurieIMUClass : public BMI160Class { private: int serial_buffer_transfer(uint8_t *buf, unsigned tx_cnt, unsigned rx_cnt); + float getFreefallDetectionThreshold(); + void setFreefallDetectionThreshold(float threshold); + float getShockDetectionThreshold(); + void setShockDetectionThreshold(float threshold); + float getMotionDetectionThreshold(); + void setMotionDetectionThreshold(float threshold); + float getZeroMotionDetectionThreshold(); + void setZeroMotionDetectionThreshold(float threshold); + float getTapDetectionThreshold(); + void setTapDetectionThreshold(float threshold); + + float getFreefallDetectionDuration(); + void setFreefallDetectionDuration(float duration); + int getShockDetectionDuration(); + void setShockDetectionDuration(int duration); + float getMotionDetectionDuration(); + void setMotionDetectionDuration(float duration); + float getZeroMotionDetectionDuration(); + void setZeroMotionDetectionDuration(float duration); + int getTapShockDuration(); + void setTapShockDuration(int duration); + int getTapQuietDuration(); + void setTapQuietDuration(int duration); + int getDoubleTapDetectionDuration(); + void setDoubleTapDetectionDuration(int duration); + + void enableInterrupt(int feature, bool enabled); + void (*_user_callback)(void); };