| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "SensorDevice.h" |
| #include "SensorFusion.h" |
| #include "SensorService.h" |
| |
| namespace android { |
| // --------------------------------------------------------------------------- |
| |
| ANDROID_SINGLETON_STATIC_INSTANCE(SensorFusion) |
| |
| SensorFusion::SensorFusion() |
| : mSensorDevice(SensorDevice::getInstance()), |
| mAttitude(mAttitudes[FUSION_9AXIS]), |
| mGyroTime(0), mAccTime(0) |
| { |
| sensor_t const* list; |
| Sensor uncalibratedGyro; |
| ssize_t count = mSensorDevice.getSensorList(&list); |
| |
| mEnabled[FUSION_9AXIS] = false; |
| mEnabled[FUSION_NOMAG] = false; |
| mEnabled[FUSION_NOGYRO] = false; |
| |
| if (count > 0) { |
| for (size_t i=0 ; i<size_t(count) ; i++) { |
| if (list[i].type == SENSOR_TYPE_ACCELEROMETER) { |
| mAcc = Sensor(list + i); |
| } |
| if (list[i].type == SENSOR_TYPE_MAGNETIC_FIELD) { |
| mMag = Sensor(list + i); |
| } |
| if (list[i].type == SENSOR_TYPE_GYROSCOPE) { |
| mGyro = Sensor(list + i); |
| } |
| if (list[i].type == SENSOR_TYPE_GYROSCOPE_UNCALIBRATED) { |
| uncalibratedGyro = Sensor(list + i); |
| } |
| } |
| |
| // Use the uncalibrated gyroscope for sensor fusion when available |
| if (uncalibratedGyro.getType() == SENSOR_TYPE_GYROSCOPE_UNCALIBRATED) { |
| mGyro = uncalibratedGyro; |
| } |
| |
| // 200 Hz for gyro events is a good compromise between precision |
| // and power/cpu usage. |
| mEstimatedGyroRate = 200; |
| mTargetDelayNs = 1000000000LL/mEstimatedGyroRate; |
| |
| for (int i = 0; i<NUM_FUSION_MODE; ++i) { |
| mFusions[i].init(i); |
| } |
| } |
| } |
| |
| void SensorFusion::process(const sensors_event_t& event) { |
| |
| if (event.type == mGyro.getType()) { |
| float dT; |
| if ( event.timestamp - mGyroTime> 0 && |
| event.timestamp - mGyroTime< (int64_t)(5e7) ) { //0.05sec |
| |
| dT = (event.timestamp - mGyroTime) / 1000000000.0f; |
| // here we estimate the gyro rate (useful for debugging) |
| const float freq = 1 / dT; |
| if (freq >= 100 && freq<1000) { // filter values obviously wrong |
| const float alpha = 1 / (1 + dT); // 1s time-constant |
| mEstimatedGyroRate = freq + (mEstimatedGyroRate - freq)*alpha; |
| } |
| |
| const vec3_t gyro(event.data); |
| for (int i = 0; i<NUM_FUSION_MODE; ++i) { |
| if (mEnabled[i]) { |
| // fusion in no gyro mode will ignore |
| mFusions[i].handleGyro(gyro, dT); |
| } |
| } |
| } |
| mGyroTime = event.timestamp; |
| } else if (event.type == SENSOR_TYPE_MAGNETIC_FIELD) { |
| const vec3_t mag(event.data); |
| for (int i = 0; i<NUM_FUSION_MODE; ++i) { |
| if (mEnabled[i]) { |
| mFusions[i].handleMag(mag);// fusion in no mag mode will ignore |
| } |
| } |
| } else if (event.type == SENSOR_TYPE_ACCELEROMETER) { |
| float dT; |
| if ( event.timestamp - mAccTime> 0 && |
| event.timestamp - mAccTime< (int64_t)(1e8) ) { //0.1sec |
| dT = (event.timestamp - mAccTime) / 1000000000.0f; |
| |
| const vec3_t acc(event.data); |
| for (int i = 0; i<NUM_FUSION_MODE; ++i) { |
| if (mEnabled[i]) { |
| mFusions[i].handleAcc(acc, dT); |
| mAttitudes[i] = mFusions[i].getAttitude(); |
| } |
| } |
| } |
| mAccTime = event.timestamp; |
| } |
| } |
| |
| template <typename T> inline T min(T a, T b) { return a<b ? a : b; } |
| template <typename T> inline T max(T a, T b) { return a>b ? a : b; } |
| |
| status_t SensorFusion::activate(int mode, void* ident, bool enabled) { |
| |
| ALOGD_IF(DEBUG_CONNECTIONS, |
| "SensorFusion::activate(mode=%d, ident=%p, enabled=%d)", |
| mode, ident, enabled); |
| |
| const ssize_t idx = mClients[mode].indexOf(ident); |
| if (enabled) { |
| if (idx < 0) { |
| mClients[mode].add(ident); |
| } |
| } else { |
| if (idx >= 0) { |
| mClients[mode].removeItemsAt(idx); |
| } |
| } |
| |
| const bool newState = mClients[mode].size() != 0; |
| if (newState != mEnabled[mode]) { |
| mEnabled[mode] = newState; |
| if (newState) { |
| mFusions[mode].init(mode); |
| } |
| } |
| |
| mSensorDevice.activate(ident, mAcc.getHandle(), enabled); |
| if (mode != FUSION_NOMAG) { |
| mSensorDevice.activate(ident, mMag.getHandle(), enabled); |
| } |
| if (mode != FUSION_NOGYRO) { |
| mSensorDevice.activate(ident, mGyro.getHandle(), enabled); |
| } |
| |
| return NO_ERROR; |
| } |
| |
| status_t SensorFusion::setDelay(int mode, void* ident, int64_t ns) { |
| // Call batch with timeout zero instead of setDelay(). |
| if (ns > (int64_t)5e7) { |
| ns = (int64_t)(5e7); |
| } |
| mSensorDevice.batch(ident, mAcc.getHandle(), 0, ns, 0); |
| if (mode != FUSION_NOMAG) { |
| mSensorDevice.batch(ident, mMag.getHandle(), 0, ms2ns(10), 0); |
| } |
| if (mode != FUSION_NOGYRO) { |
| mSensorDevice.batch(ident, mGyro.getHandle(), 0, mTargetDelayNs, 0); |
| } |
| return NO_ERROR; |
| } |
| |
| |
| float SensorFusion::getPowerUsage(int mode) const { |
| float power = mAcc.getPowerUsage() + |
| ((mode != FUSION_NOMAG) ? mMag.getPowerUsage() : 0) + |
| ((mode != FUSION_NOGYRO) ? mGyro.getPowerUsage() : 0); |
| return power; |
| } |
| |
| int32_t SensorFusion::getMinDelay() const { |
| return mAcc.getMinDelay(); |
| } |
| |
| void SensorFusion::dump(String8& result) { |
| const Fusion& fusion_9axis(mFusions[FUSION_9AXIS]); |
| result.appendFormat("9-axis fusion %s (%zd clients), gyro-rate=%7.2fHz, " |
| "q=< %g, %g, %g, %g > (%g), " |
| "b=< %g, %g, %g >\n", |
| mEnabled[FUSION_9AXIS] ? "enabled" : "disabled", |
| mClients[FUSION_9AXIS].size(), |
| mEstimatedGyroRate, |
| fusion_9axis.getAttitude().x, |
| fusion_9axis.getAttitude().y, |
| fusion_9axis.getAttitude().z, |
| fusion_9axis.getAttitude().w, |
| length(fusion_9axis.getAttitude()), |
| fusion_9axis.getBias().x, |
| fusion_9axis.getBias().y, |
| fusion_9axis.getBias().z); |
| |
| const Fusion& fusion_nomag(mFusions[FUSION_NOMAG]); |
| result.appendFormat("game fusion(no mag) %s (%zd clients), " |
| "gyro-rate=%7.2fHz, " |
| "q=< %g, %g, %g, %g > (%g), " |
| "b=< %g, %g, %g >\n", |
| mEnabled[FUSION_NOMAG] ? "enabled" : "disabled", |
| mClients[FUSION_NOMAG].size(), |
| mEstimatedGyroRate, |
| fusion_nomag.getAttitude().x, |
| fusion_nomag.getAttitude().y, |
| fusion_nomag.getAttitude().z, |
| fusion_nomag.getAttitude().w, |
| length(fusion_nomag.getAttitude()), |
| fusion_nomag.getBias().x, |
| fusion_nomag.getBias().y, |
| fusion_nomag.getBias().z); |
| |
| const Fusion& fusion_nogyro(mFusions[FUSION_NOGYRO]); |
| result.appendFormat("geomag fusion (no gyro) %s (%zd clients), " |
| "gyro-rate=%7.2fHz, " |
| "q=< %g, %g, %g, %g > (%g), " |
| "b=< %g, %g, %g >\n", |
| mEnabled[FUSION_NOGYRO] ? "enabled" : "disabled", |
| mClients[FUSION_NOGYRO].size(), |
| mEstimatedGyroRate, |
| fusion_nogyro.getAttitude().x, |
| fusion_nogyro.getAttitude().y, |
| fusion_nogyro.getAttitude().z, |
| fusion_nogyro.getAttitude().w, |
| length(fusion_nogyro.getAttitude()), |
| fusion_nogyro.getBias().x, |
| fusion_nogyro.getBias().y, |
| fusion_nogyro.getBias().z); |
| } |
| |
| // --------------------------------------------------------------------------- |
| }; // namespace android |
