/*
* Copyright (C) 2011 Invensense, Inc.
*
* 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.
*/
//#define LOG_NDEBUG 0
//see also the EXTRA_VERBOSE define, below
#include <fcntl.h>
#include <errno.h>
#include <math.h>
#include <float.h>
#include <poll.h>
#include <unistd.h>
#include <dirent.h>
#include <stdlib.h>
#include <sys/select.h>
#include <dlfcn.h>
#include <pthread.h>
#include <cutils/log.h>
#include <utils/KeyedVector.h>
#include "MPLSensor.h"
#include "math.h"
#include "ml.h"
#include "mlFIFO.h"
#include "mlsl.h"
#include "mlos.h"
#include "ml_mputest.h"
#include "ml_stored_data.h"
#include "mldl_cfg.h"
#include "mldl.h"
#include "mpu.h"
#include "accel.h"
#include "compass.h"
#include "kernel/timerirq.h"
#include "kernel/mpuirq.h"
#include "kernel/slaveirq.h"
extern "C" {
#include "mlsupervisor.h"
}
#include "mlcontrol.h"
#include "sensor_params.h"
#define EXTRA_VERBOSE (0)
//#define FUNC_LOG ALOGV("%s", __PRETTY_FUNCTION__)
#define FUNC_LOG
#define VFUNC_LOG ALOGV_IF(EXTRA_VERBOSE, "%s", __PRETTY_FUNCTION__)
/* this mask must turn on only the sensors that are present and managed by the MPL */
#define ALL_MPL_SENSORS_NP (INV_THREE_AXIS_ACCEL | INV_THREE_AXIS_COMPASS | INV_THREE_AXIS_GYRO)
#define CALL_MEMBER_FN(pobject,ptrToMember) ((pobject)->*(ptrToMember))
/******************************************/
/* Base values for the sensor list, these need to be in the order defined in MPLSensor.h */
static struct sensor_t sSensorList[] =
{ { "MPL Gyroscope", "Invensense", 1,
SENSORS_GYROSCOPE_HANDLE,
SENSOR_TYPE_GYROSCOPE, 2000.0f, 1.0f, 0.5f, 10000, { } },
{ "MPL Accelerometer", "Invensense", 1,
SENSORS_ACCELERATION_HANDLE,
SENSOR_TYPE_ACCELEROMETER, 10240.0f, 1.0f, 0.5f, 10000, { } },
{ "MPL Magnetic Field", "Invensense", 1,
SENSORS_MAGNETIC_FIELD_HANDLE,
SENSOR_TYPE_MAGNETIC_FIELD, 10240.0f, 1.0f, 0.5f, 10000, { } },
{ "MPL Orientation", "Invensense", 1,
SENSORS_ORIENTATION_HANDLE,
SENSOR_TYPE_ORIENTATION, 360.0f, 1.0f, 9.7f, 10000, { } },
{ "MPL Rotation Vector", "Invensense", 1,
SENSORS_ROTATION_VECTOR_HANDLE,
SENSOR_TYPE_ROTATION_VECTOR, 10240.0f, 1.0f, 0.5f, 10000, { } },
{ "MPL Linear Acceleration", "Invensense", 1,
SENSORS_LINEAR_ACCEL_HANDLE,
SENSOR_TYPE_LINEAR_ACCELERATION, 10240.0f, 1.0f, 0.5f, 10000, { } },
{ "MPL Gravity", "Invensense", 1,
SENSORS_GRAVITY_HANDLE,
SENSOR_TYPE_GRAVITY, 10240.0f, 1.0f, 0.5f, 10000, { } },
};
static unsigned long long irq_timestamp = 0;
/* ***************************************************************************
* MPL interface misc.
*/
//static pointer to the object that will handle callbacks
static MPLSensor* gMPLSensor = NULL;
/* we need to pass some callbacks to the MPL. The mpl is a C library, so
* wrappers for the C++ callback implementations are required.
*/
extern "C" {
//callback wrappers go here
void mot_cb_wrapper(uint16_t val)
{
if (gMPLSensor) {
gMPLSensor->cbOnMotion(val);
}
}
void procData_cb_wrapper()
{
if(gMPLSensor) {
gMPLSensor->cbProcData();
}
}
} //end of extern C
void setCallbackObject(MPLSensor* gbpt)
{
gMPLSensor = gbpt;
}
/*****************************************************************************
* sensor class implementation
*/
#define GY_ENABLED ((1<<ID_GY) & enabled_sensors)
#define A_ENABLED ((1<<ID_A) & enabled_sensors)
#define O_ENABLED ((1<<ID_O) & enabled_sensors)
#define M_ENABLED ((1<<ID_M) & enabled_sensors)
#define LA_ENABLED ((1<<ID_LA) & enabled_sensors)
#define GR_ENABLED ((1<<ID_GR) & enabled_sensors)
#define RV_ENABLED ((1<<ID_RV) & enabled_sensors)
MPLSensor::MPLSensor() :
SensorBase(NULL, NULL),
mMpuAccuracy(0), mNewData(0),
mDmpStarted(false),
mMasterSensorMask(INV_ALL_SENSORS),
mLocalSensorMask(ALL_MPL_SENSORS_NP), mPollTime(-1),
mCurFifoRate(-1), mHaveGoodMpuCal(false), mHaveGoodCompassCal(false),
mUseTimerIrqAccel(false), mUsetimerIrqCompass(true),
mUseTimerirq(false), mSampleCount(0),
mEnabled(0), mPendingMask(0)
{
FUNC_LOG;
inv_error_t rv;
int mpu_int_fd, i;
char *port = NULL;
ALOGV_IF(EXTRA_VERBOSE, "MPLSensor constructor: numSensors = %d", numSensors);
pthread_mutex_init(&mMplMutex, NULL);
mForceSleep = false;
/* used for identifying whether 9axis is enabled or not */
/* this variable will be changed in initMPL() when libmpl is loaded */
/* sensor list will be changed based on this variable */
mNineAxisEnabled = false;
for (i = 0; i < ARRAY_SIZE(mPollFds); i++) {
mPollFds[i].fd = -1;
mPollFds[i].events = 0;
}
pthread_mutex_lock(&mMplMutex);
mpu_int_fd = open("/dev/mpuirq", O_RDWR);
if (mpu_int_fd == -1) {
ALOGE("could not open the mpu irq device node");
} else {
fcntl(mpu_int_fd, F_SETFL, O_NONBLOCK);
//ioctl(mpu_int_fd, MPUIRQ_SET_TIMEOUT, 0);
mIrqFds.add(MPUIRQ_FD, mpu_int_fd);
mPollFds[MPUIRQ_FD].fd = mpu_int_fd;
mPollFds[MPUIRQ_FD].events = POLLIN;
}
accel_fd = open("/dev/accelirq", O_RDWR);
if (accel_fd == -1) {
ALOGE("could not open the accel irq device node");
} else {
fcntl(accel_fd, F_SETFL, O_NONBLOCK);
//ioctl(accel_fd, SLAVEIRQ_SET_TIMEOUT, 0);
mIrqFds.add(ACCELIRQ_FD, accel_fd);
mPollFds[ACCELIRQ_FD].fd = accel_fd;
mPollFds[ACCELIRQ_FD].events = POLLIN;
}
timer_fd = open("/dev/timerirq", O_RDWR);
if (timer_fd == -1) {
ALOGE("could not open the timer irq device node");
} else {
fcntl(timer_fd, F_SETFL, O_NONBLOCK);
//ioctl(timer_fd, TIMERIRQ_SET_TIMEOUT, 0);
mIrqFds.add(TIMERIRQ_FD, timer_fd);
mPollFds[TIMERIRQ_FD].fd = timer_fd;
mPollFds[TIMERIRQ_FD].events = POLLIN;
}
data_fd = mpu_int_fd;
if ((accel_fd == -1) && (timer_fd != -1)) {
//no accel irq and timer available
mUseTimerIrqAccel = true;
//ALOGD("MPLSensor falling back to timerirq for accel data");
}
memset(mPendingEvents, 0, sizeof(mPendingEvents));
mPendingEvents[RotationVector].version = sizeof(sensors_event_t);
mPendingEvents[RotationVector].sensor = ID_RV;
mPendingEvents[RotationVector].type = SENSOR_TYPE_ROTATION_VECTOR;
mPendingEvents[RotationVector].acceleration.status
= SENSOR_STATUS_ACCURACY_HIGH;
mPendingEvents[LinearAccel].version = sizeof(sensors_event_t);
mPendingEvents[LinearAccel].sensor = ID_LA;
mPendingEvents[LinearAccel].type = SENSOR_TYPE_LINEAR_ACCELERATION;
mPendingEvents[LinearAccel].acceleration.status
= SENSOR_STATUS_ACCURACY_HIGH;
mPendingEvents[Gravity].version = sizeof(sensors_event_t);
mPendingEvents[Gravity].sensor = ID_GR;
mPendingEvents[Gravity].type = SENSOR_TYPE_GRAVITY;
mPendingEvents[Gravity].acceleration.status = SENSOR_STATUS_ACCURACY_HIGH;
mPendingEvents[Gyro].version = sizeof(sensors_event_t);
mPendingEvents[Gyro].sensor = ID_GY;
mPendingEvents[Gyro].type = SENSOR_TYPE_GYROSCOPE;
mPendingEvents[Gyro].gyro.status = SENSOR_STATUS_ACCURACY_HIGH;
mPendingEvents[Accelerometer].version = sizeof(sensors_event_t);
mPendingEvents[Accelerometer].sensor = ID_A;
mPendingEvents[Accelerometer].type = SENSOR_TYPE_ACCELEROMETER;
mPendingEvents[Accelerometer].acceleration.status
= SENSOR_STATUS_ACCURACY_HIGH;
mPendingEvents[MagneticField].version = sizeof(sensors_event_t);
mPendingEvents[MagneticField].sensor = ID_M;
mPendingEvents[MagneticField].type = SENSOR_TYPE_MAGNETIC_FIELD;
mPendingEvents[MagneticField].magnetic.status = SENSOR_STATUS_ACCURACY_HIGH;
mPendingEvents[Orientation].version = sizeof(sensors_event_t);
mPendingEvents[Orientation].sensor = ID_O;
mPendingEvents[Orientation].type = SENSOR_TYPE_ORIENTATION;
mPendingEvents[Orientation].orientation.status
= SENSOR_STATUS_ACCURACY_HIGH;
mHandlers[RotationVector] = &MPLSensor::rvHandler;
mHandlers[LinearAccel] = &MPLSensor::laHandler;
mHandlers[Gravity] = &MPLSensor::gravHandler;
mHandlers[Gyro] = &MPLSensor::gyroHandler;
mHandlers[Accelerometer] = &MPLSensor::accelHandler;
mHandlers[MagneticField] = &MPLSensor::compassHandler;
mHandlers[Orientation] = &MPLSensor::orienHandler;
for (int i = 0; i < numSensors; i++)
mDelays[i] = 30000000LLU; // 30 ms by default
if (inv_serial_start(port) != INV_SUCCESS) {
ALOGE("Fatal Error : could not open MPL serial interface");
}
//initialize library parameters
initMPL();
//setup the FIFO contents
setupFIFO();
//we start the motion processing only when a sensor is enabled...
//rv = inv_dmp_start();
//ALOGE_IF(rv != INV_SUCCESS, "Fatal error: could not start the DMP correctly. (code = %d)\n", rv);
//dmp_started = true;
pthread_mutex_unlock(&mMplMutex);
}
MPLSensor::~MPLSensor()
{
FUNC_LOG;
pthread_mutex_lock(&mMplMutex);
if (inv_dmp_stop() != INV_SUCCESS) {
ALOGW("Error: could not stop the DMP correctly.\n");
}
if (inv_dmp_close() != INV_SUCCESS) {
ALOGW("Error: could not close the DMP");
}
if (inv_serial_stop() != INV_SUCCESS) {
ALOGW("Error : could not close the serial port");
}
pthread_mutex_unlock(&mMplMutex);
pthread_mutex_destroy(&mMplMutex);
}
/* clear any data from our various filehandles */
void MPLSensor::clearIrqData(bool* irq_set)
{
unsigned int i;
int nread;
struct mpuirq_data irqdata;
poll(mPollFds, ARRAY_SIZE(mPollFds), 0); //check which ones need to be cleared
for (i = 0; i < ARRAY_SIZE(mPollFds); i++) {
int cur_fd = mPollFds[i].fd;
int j = 0;
if (mPollFds[i].revents & POLLIN) {
nread = read(cur_fd, &irqdata, sizeof(irqdata));
if (nread > 0) {
irq_set[i] = true;
irq_timestamp = irqdata.irqtime;
//ALOGV_IF(EXTRA_VERBOSE, "irq: %d %d (%d)", i, irqdata.interruptcount, j++);
}
}
mPollFds[i].revents = 0;
}
}
/* set the power states of the various sensors based on the bits set in the
* enabled_sensors parameter.
* this function modifies globalish state variables. It must be called with the mMplMutex held. */
void MPLSensor::setPowerStates(int enabled_sensors)
{
FUNC_LOG;
bool irq_set[5] = { false, false, false, false, false };
//ALOGV(" setPowerStates: %d dmp_started: %d", enabled_sensors, mDmpStarted);
do {
if (LA_ENABLED || GR_ENABLED || RV_ENABLED || O_ENABLED) {
mLocalSensorMask = ALL_MPL_SENSORS_NP;
break;
}
if (!A_ENABLED && !M_ENABLED && !GY_ENABLED) {
mLocalSensorMask = 0;
break;
}
if (GY_ENABLED) {
mLocalSensorMask |= INV_THREE_AXIS_GYRO;
} else {
mLocalSensorMask &= ~INV_THREE_AXIS_GYRO;
}
if (A_ENABLED) {
mLocalSensorMask |= (INV_THREE_AXIS_ACCEL);
} else {
mLocalSensorMask &= ~(INV_THREE_AXIS_ACCEL);
}
if (M_ENABLED) {
mLocalSensorMask |= INV_THREE_AXIS_COMPASS;
} else {
mLocalSensorMask &= ~(INV_THREE_AXIS_COMPASS);
}
} while (0);
//record the new sensor state
inv_error_t rv;
long sen_mask = mLocalSensorMask & mMasterSensorMask;
bool changing_sensors = ((inv_get_dl_config()->requested_sensors
!= sen_mask) && (sen_mask != 0));
bool restart = (!mDmpStarted) && (sen_mask != 0);
if (changing_sensors || restart) {
ALOGV_IF(EXTRA_VERBOSE, "cs:%d rs:%d ", changing_sensors, restart);
if (mDmpStarted) {
inv_dmp_stop();
clearIrqData(irq_set);
mDmpStarted = false;
}
if (sen_mask != inv_get_dl_config()->requested_sensors) {
//ALOGV("setPowerStates: %lx", sen_mask);
rv = inv_set_mpu_sensors(sen_mask);
ALOGE_IF(rv != INV_SUCCESS,
"error: unable to set MPL sensor power states (sens=%ld retcode = %d)",
sen_mask, rv);
}
if (((mUsetimerIrqCompass && (sen_mask == INV_THREE_AXIS_COMPASS))
|| (mUseTimerIrqAccel && (sen_mask & INV_THREE_AXIS_ACCEL)))
&& ((sen_mask & INV_DMP_PROCESSOR) == 0)) {
ALOGV_IF(EXTRA_VERBOSE, "Allowing TimerIRQ");
mUseTimerirq = true;
} else {
if (mUseTimerirq) {
ioctl(mIrqFds.valueFor(TIMERIRQ_FD), TIMERIRQ_STOP, 0);
clearIrqData(irq_set);
}
ALOGV_IF(EXTRA_VERBOSE, "Not allowing TimerIRQ");
mUseTimerirq = false;
}
if (!mDmpStarted) {
if (mHaveGoodMpuCal || mHaveGoodCompassCal) {
rv = inv_store_calibration();
ALOGE_IF(rv != INV_SUCCESS,
"error: unable to store MPL calibration file");
mHaveGoodMpuCal = false;
mHaveGoodCompassCal = false;
}
//ALOGV("Starting DMP");
rv = inv_dmp_start();
ALOGE_IF(rv != INV_SUCCESS, "unable to start dmp");
mDmpStarted = true;
}
}
//check if we should stop the DMP
if (mDmpStarted && (sen_mask == 0)) {
//ALOGV("Stopping DMP");
rv = inv_dmp_stop();
ALOGE_IF(rv != INV_SUCCESS, "error: unable to stop DMP (retcode = %d)",
rv);
if (mUseTimerirq) {
ioctl(mIrqFds.valueFor(TIMERIRQ_FD), TIMERIRQ_STOP, 0);
}
clearIrqData(irq_set);
mDmpStarted = false;
mPollTime = -1;
mCurFifoRate = -1;
}
}
/**
* container function for all the calls we make once to set up the MPL.
*/
void MPLSensor::initMPL()
{
FUNC_LOG;
inv_error_t result;
unsigned short bias_update_mask = 0xFFFF;
struct mldl_cfg *mldl_cfg;
if (inv_dmp_open() != INV_SUCCESS) {
ALOGE("Fatal Error : could not open DMP correctly.\n");
}
result = inv_set_mpu_sensors(ALL_MPL_SENSORS_NP); //default to all sensors, also makes 9axis enable work
ALOGE_IF(result != INV_SUCCESS,
"Fatal Error : could not set enabled sensors.");
if (inv_load_calibration() != INV_SUCCESS) {
ALOGE("could not open MPL calibration file");
}
//check for the 9axis fusion library: if available load it and start 9x
void* h_dmp_lib=dlopen("libinvensense_mpl.so", RTLD_NOW);
if(h_dmp_lib) {
const char* error;
error = dlerror();
inv_error_t (*fp_inv_enable_9x_fusion)() =
(inv_error_t(*)()) dlsym(h_dmp_lib, "inv_enable_9x_fusion");
if((error = dlerror()) != NULL) {
ALOGE("%s %s", error, "inv_enable_9x_fusion");
} else if ((*fp_inv_enable_9x_fusion)() != INV_SUCCESS) {
ALOGE( "Warning : 9 axis sensor fusion not available "
"- No compass detected.\n");
} else {
/* 9axis is loaded and enabled */
/* this variable is used for coming up with sensor list */
mNineAxisEnabled = true;
}
} else {
const char* error = dlerror();
ALOGE("libinvensense_mpl.so not found, 9x sensor fusion disabled (%s)",error);
}
mldl_cfg = inv_get_dl_config();
if (inv_set_bias_update(bias_update_mask) != INV_SUCCESS) {
ALOGE("Error : Bias update function could not be set.\n");
}
if (inv_set_motion_interrupt(1) != INV_SUCCESS) {
ALOGE("Error : could not set motion interrupt");
}
if (inv_set_fifo_interrupt(1) != INV_SUCCESS) {
ALOGE("Error : could not set fifo interrupt");
}
result = inv_set_fifo_rate(6);
if (result != INV_SUCCESS) {
ALOGE("Fatal error: inv_set_fifo_rate returned %d\n", result);
}
mMpuAccuracy = SENSOR_STATUS_ACCURACY_MEDIUM;
setupCallbacks();
}
/** setup the fifo contents.
*/
void MPLSensor::setupFIFO()
{
FUNC_LOG;
inv_error_t result;
result = inv_send_accel(INV_ALL, INV_32_BIT);
if (result != INV_SUCCESS) {
ALOGE("Fatal error: inv_send_accel returned %d\n", result);
}
result = inv_send_quaternion(INV_32_BIT);
if (result != INV_SUCCESS) {
ALOGE("Fatal error: inv_send_quaternion returned %d\n", result);
}
result = inv_send_linear_accel(INV_ALL, INV_32_BIT);
if (result != INV_SUCCESS) {
ALOGE("Fatal error: inv_send_linear_accel returned %d\n", result);
}
result = inv_send_linear_accel_in_world(INV_ALL, INV_32_BIT);
if (result != INV_SUCCESS) {
ALOGE("Fatal error: inv_send_linear_accel_in_world returned %d\n",
result);
}
result = inv_send_gravity(INV_ALL, INV_32_BIT);
if (result != INV_SUCCESS) {
ALOGE("Fatal error: inv_send_gravity returned %d\n", result);
}
result = inv_send_gyro(INV_ALL, INV_32_BIT);
if (result != INV_SUCCESS) {
ALOGE("Fatal error: inv_send_gyro returned %d\n", result);
}
}
/**
* set up the callbacks that we use in all cases (outside of gestures, etc)
*/
void MPLSensor::setupCallbacks()
{
FUNC_LOG;
if (inv_set_motion_callback(mot_cb_wrapper) != INV_SUCCESS) {
ALOGE("Error : Motion callback could not be set.\n");
}
if (inv_set_fifo_processed_callback(procData_cb_wrapper) != INV_SUCCESS) {
ALOGE("Error : Processed data callback could not be set.");
}
}
/**
* handle the motion/no motion output from the MPL.
*/
void MPLSensor::cbOnMotion(uint16_t val)
{
FUNC_LOG;
//after the first no motion, the gyro should be calibrated well
if (val == 2) {
mMpuAccuracy = SENSOR_STATUS_ACCURACY_HIGH;
if ((inv_get_dl_config()->requested_sensors) & INV_THREE_AXIS_GYRO) {
//if gyros are on and we got a no motion, set a flag
// indicating that the cal file can be written.
mHaveGoodMpuCal = true;
}
}
return;
}
void MPLSensor::cbProcData()
{
mNewData = 1;
mSampleCount++;
//ALOGV_IF(EXTRA_VERBOSE, "new data (%d)", sampleCount);
}
//these handlers transform mpl data into one of the Android sensor types
// scaling and coordinate transforms should be done in the handlers
void MPLSensor::gyroHandler(sensors_event_t* s, uint32_t* pending_mask,
int index)
{
VFUNC_LOG;
inv_error_t res;
res = inv_get_float_array(INV_GYROS, s->gyro.v);
s->gyro.v[0] = s->gyro.v[0] * M_PI / 180.0;
s->gyro.v[1] = s->gyro.v[1] * M_PI / 180.0;
s->gyro.v[2] = s->gyro.v[2] * M_PI / 180.0;
s->gyro.status = mMpuAccuracy;
if (res == INV_SUCCESS)
*pending_mask |= (1 << index);
}
void MPLSensor::accelHandler(sensors_event_t* s, uint32_t* pending_mask,
int index)
{
//VFUNC_LOG;
inv_error_t res;
res = inv_get_float_array(INV_ACCELS, s->acceleration.v);
//res = inv_get_accel_float(s->acceleration.v);
s->acceleration.v[0] = s->acceleration.v[0] * 9.81;
s->acceleration.v[1] = s->acceleration.v[1] * 9.81;
s->acceleration.v[2] = s->acceleration.v[2] * 9.81;
//ALOGV_IF(EXTRA_VERBOSE, "accel data: %f %f %f", s->acceleration.v[0], s->acceleration.v[1], s->acceleration.v[2]);
s->acceleration.status = SENSOR_STATUS_ACCURACY_HIGH;
if (res == INV_SUCCESS)
*pending_mask |= (1 << index);
}
int MPLSensor::estimateCompassAccuracy()
{
inv_error_t res;
int rv;
res = inv_get_compass_accuracy(&rv);
if(rv >= SENSOR_STATUS_ACCURACY_MEDIUM) {
mHaveGoodCompassCal = true;
}
ALOGE_IF(res != INV_SUCCESS, "error returned from inv_get_compass_accuracy");
return rv;
}
void MPLSensor::compassHandler(sensors_event_t* s, uint32_t* pending_mask,
int index)
{
VFUNC_LOG;
inv_error_t res, res2;
float bias_error[3];
float total_be;
static int bias_error_settled = 0;
res = inv_get_float_array(INV_MAGNETOMETER, s->magnetic.v);
if (res != INV_SUCCESS) {
ALOGW(
"compass_handler inv_get_float_array(INV_MAGNETOMETER) returned %d",
res);
}
s->magnetic.status = estimateCompassAccuracy();
if (res == INV_SUCCESS)
*pending_mask |= (1 << index);
}
void MPLSensor::rvHandler(sensors_event_t* s, uint32_t* pending_mask,
int index)
{
VFUNC_LOG;
float quat[4];
float norm = 0;
float ang = 0;
inv_error_t r;
r = inv_get_float_array(INV_QUATERNION, quat);
if (r != INV_SUCCESS) {
*pending_mask &= ~(1 << index);
return;
} else {
*pending_mask |= (1 << index);
}
norm = quat[1] * quat[1] + quat[2] * quat[2] + quat[3] * quat[3]
+ FLT_EPSILON;
if (norm > 1.0f) {
//renormalize
norm = sqrtf(norm);
float inv_norm = 1.0f / norm;
quat[1] = quat[1] * inv_norm;
quat[2] = quat[2] * inv_norm;
quat[3] = quat[3] * inv_norm;
}
if (quat[0] < 0.0) {
quat[1] = -quat[1];
quat[2] = -quat[2];
quat[3] = -quat[3];
}
s->gyro.v[0] = quat[1];
s->gyro.v[1] = quat[2];
s->gyro.v[2] = quat[3];
s->gyro.status
= ((mMpuAccuracy < estimateCompassAccuracy()) ? mMpuAccuracy
: estimateCompassAccuracy());
}
void MPLSensor::laHandler(sensors_event_t* s, uint32_t* pending_mask,
int index)
{
VFUNC_LOG;
inv_error_t res;
res = inv_get_float_array(INV_LINEAR_ACCELERATION, s->gyro.v);
s->gyro.v[0] *= 9.81;
s->gyro.v[1] *= 9.81;
s->gyro.v[2] *= 9.81;
s->gyro.status = mMpuAccuracy;
if (res == INV_SUCCESS)
*pending_mask |= (1 << index);
}
void MPLSensor::gravHandler(sensors_event_t* s, uint32_t* pending_mask,
int index)
{
VFUNC_LOG;
inv_error_t res;
res = inv_get_float_array(INV_GRAVITY, s->gyro.v);
s->gyro.v[0] *= 9.81;
s->gyro.v[1] *= 9.81;
s->gyro.v[2] *= 9.81;
s->gyro.status = mMpuAccuracy;
if (res == INV_SUCCESS)
*pending_mask |= (1 << index);
}
void MPLSensor::calcOrientationSensor(float *R, float *values)
{
float tmp;
//Azimuth
if ((R[7] > 0.7071067f) || ((R[8] < 0) && (fabs(R[7]) > fabs(R[6])))) {
values[0] = (float) atan2f(-R[3], R[0]);
} else {
values[0] = (float) atan2f(R[1], R[4]);
}
values[0] *= 57.295779513082320876798154814105f;
if (values[0] < 0) {
values[0] += 360.0f;
}
//Pitch
tmp = R[7];
if (tmp > 1.0f)
tmp = 1.0f;
if (tmp < -1.0f)
tmp = -1.0f;
values[1] = -asinf(tmp) * 57.295779513082320876798154814105f;
if (R[8] < 0) {
values[1] = 180.0f - values[1];
}
if (values[1] > 180.0f) {
values[1] -= 360.0f;
}
//Roll
if ((R[7] > 0.7071067f)) {
values[2] = (float) atan2f(R[6], R[7]);
} else {
values[2] = (float) atan2f(R[6], R[8]);
}
values[2] *= 57.295779513082320876798154814105f;
if (values[2] > 90.0f) {
values[2] = 180.0f - values[2];
}
if (values[2] < -90.0f) {
values[2] = -180.0f - values[2];
}
}
void MPLSensor::orienHandler(sensors_event_t* s, uint32_t* pending_mask,
int index) //note that this is the handler for the android 'orientation' sensor, not the mpl orientation output
{
VFUNC_LOG;
inv_error_t res;
float euler[3];
float heading[1];
float rot_mat[9];
res = inv_get_float_array(INV_ROTATION_MATRIX, rot_mat);
//ComputeAndOrientation(heading[0], euler, s->orientation.v);
calcOrientationSensor(rot_mat, s->orientation.v);
s->orientation.status = estimateCompassAccuracy();
if (res == INV_SUCCESS)
*pending_mask |= (1 << index);
else
ALOGW("orienHandler: data not valid (%d)", (int) res);
}
int MPLSensor::enable(int32_t handle, int en)
{
FUNC_LOG;
//ALOGV("handle : %d en: %d", handle, en);
int what = -1;
switch (handle) {
case ID_A:
what = Accelerometer;
break;
case ID_M:
what = MagneticField;
break;
case ID_O:
what = Orientation;
break;
case ID_GY:
what = Gyro;
break;
case ID_GR:
what = Gravity;
break;
case ID_RV:
what = RotationVector;
break;
case ID_LA:
what = LinearAccel;
break;
default: //this takes care of all the gestures
what = handle;
break;
}
if (uint32_t(what) >= numSensors)
return -EINVAL;
int newState = en ? 1 : 0;
int err = 0;
//ALOGV_IF((uint32_t(newState) << what) != (mEnabled & (1 << what)),
// "sensor state change what=%d", what);
pthread_mutex_lock(&mMplMutex);
if ((uint32_t(newState) << what) != (mEnabled & (1 << what))) {
uint32_t sensor_type;
short flags = newState;
mEnabled &= ~(1 << what);
mEnabled |= (uint32_t(flags) << what);
ALOGV_IF(EXTRA_VERBOSE, "mEnabled = %x", mEnabled);
setPowerStates(mEnabled);
pthread_mutex_unlock(&mMplMutex);
if (!newState)
update_delay();
return err;
}
pthread_mutex_unlock(&mMplMutex);
return err;
}
int MPLSensor::setDelay(int32_t handle, int64_t ns)
{
FUNC_LOG;
ALOGV_IF(EXTRA_VERBOSE,
" setDelay handle: %d rate %d", handle, (int) (ns / 1000000LL));
int what = -1;
switch (handle) {
case ID_A:
what = Accelerometer;
break;
case ID_M:
what = MagneticField;
break;
case ID_O:
what = Orientation;
break;
case ID_GY:
what = Gyro;
break;
case ID_GR:
what = Gravity;
break;
case ID_RV:
what = RotationVector;
break;
case ID_LA:
what = LinearAccel;
break;
default:
what = handle;
break;
}
if (uint32_t(what) >= numSensors)
return -EINVAL;
if (ns < 0)
return -EINVAL;
pthread_mutex_lock(&mMplMutex);
mDelays[what] = ns;
pthread_mutex_unlock(&mMplMutex);
return update_delay();
}
int MPLSensor::update_delay()
{
FUNC_LOG;
int rv = 0;
bool irq_set[5];
pthread_mutex_lock(&mMplMutex);
if (mEnabled) {
uint64_t wanted = -1LLU;
for (int i = 0; i < numSensors; i++) {
if (mEnabled & (1 << i)) {
uint64_t ns = mDelays[i];
wanted = wanted < ns ? wanted : ns;
}
}
//Limit all rates to 100Hz max. 100Hz = 10ms = 10000000ns
if (wanted < 10000000LLU) {
wanted = 10000000LLU;
}
int rate = ((wanted) / 5000000LLU) - ((wanted % 5000000LLU == 0) ? 1
: 0); //mpu fifo rate is in increments of 5ms
if (rate == 0) //KLP disallow fifo rate 0
rate = 1;
if (rate != mCurFifoRate) {
//ALOGD("set fifo rate: %d %llu", rate, wanted);
inv_error_t res; // = inv_dmp_stop();
res = inv_set_fifo_rate(rate);
ALOGE_IF(res != INV_SUCCESS, "error setting FIFO rate");
//res = inv_dmp_start();
//ALOGE_IF(res != INV_SUCCESS, "error re-starting DMP");
mCurFifoRate = rate;
rv = (res == INV_SUCCESS);
}
if (((inv_get_dl_config()->requested_sensors & INV_DMP_PROCESSOR) == 0)) {
if (mUseTimerirq) {
ioctl(mIrqFds.valueFor(TIMERIRQ_FD), TIMERIRQ_STOP, 0);
clearIrqData(irq_set);
if (inv_get_dl_config()->requested_sensors
== INV_THREE_AXIS_COMPASS) {
ioctl(mIrqFds.valueFor(TIMERIRQ_FD), TIMERIRQ_START,
(unsigned long) (wanted / 1000000LLU));
ALOGV_IF(EXTRA_VERBOSE, "updated timerirq period to %d",
(int) (wanted / 1000000LLU));
} else {
ioctl(mIrqFds.valueFor(TIMERIRQ_FD), TIMERIRQ_START,
(unsigned long) inv_get_sample_step_size_ms());
ALOGV_IF(EXTRA_VERBOSE, "updated timerirq period to %d",
(int) inv_get_sample_step_size_ms());
}
}
}
}
pthread_mutex_unlock(&mMplMutex);
return rv;
}
/* return the current time in nanoseconds */
int64_t MPLSensor::now_ns(void)
{
//FUNC_LOG;
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
//ALOGV("Time %lld", (int64_t)ts.tv_sec * 1000000000 + ts.tv_nsec);
return (int64_t) ts.tv_sec * 1000000000 + ts.tv_nsec;
}
int MPLSensor::readEvents(sensors_event_t* data, int count)
{
//VFUNC_LOG;
int i;
bool irq_set[5] = { false, false, false, false, false };
inv_error_t rv;
if (count < 1)
return -EINVAL;
int numEventReceived = 0;
clearIrqData(irq_set);
pthread_mutex_lock(&mMplMutex);
if (mDmpStarted) {
//ALOGV_IF(EXTRA_VERBOSE, "Update Data");
rv = inv_update_data();
ALOGE_IF(rv != INV_SUCCESS, "inv_update_data error (code %d)", (int) rv);
}
else {
//probably just one extra read after shutting down
ALOGV_IF(EXTRA_VERBOSE,
"MPLSensor::readEvents called, but there's nothing to do.");
}
pthread_mutex_unlock(&mMplMutex);
if (!mNewData) {
ALOGV_IF(EXTRA_VERBOSE, "no new data");
return 0;
}
mNewData = 0;
/* google timestamp */
pthread_mutex_lock(&mMplMutex);
for (int i = 0; i < numSensors; i++) {
if (mEnabled & (1 << i)) {
CALL_MEMBER_FN(this,mHandlers[i])(mPendingEvents + i,
&mPendingMask, i);
mPendingEvents[i].timestamp = irq_timestamp;
}
}
for (int j = 0; count && mPendingMask && j < numSensors; j++) {
if (mPendingMask & (1 << j)) {
mPendingMask &= ~(1 << j);
if (mEnabled & (1 << j)) {
*data++ = mPendingEvents[j];
count--;
numEventReceived++;
}
}
}
pthread_mutex_unlock(&mMplMutex);
return numEventReceived;
}
int MPLSensor::getFd() const
{
//ALOGV("MPLSensor::getFd returning %d", data_fd);
return data_fd;
}
int MPLSensor::getAccelFd() const
{
//ALOGV("MPLSensor::getAccelFd returning %d", accel_fd);
return accel_fd;
}
int MPLSensor::getTimerFd() const
{
//ALOGV("MPLSensor::getTimerFd returning %d", timer_fd);
return timer_fd;
}
int MPLSensor::getPowerFd() const
{
int hdl = (int) inv_get_serial_handle();
//ALOGV("MPLSensor::getPowerFd returning %d", hdl);
return hdl;
}
int MPLSensor::getPollTime()
{
return mPollTime;
}
bool MPLSensor::hasPendingEvents() const
{
//if we are using the polling workaround, force the main loop to check for data every time
return (mPollTime != -1);
}
void MPLSensor::handlePowerEvent()
{
VFUNC_LOG;
mpuirq_data irqd;
int fd = (int) inv_get_serial_handle();
read(fd, &irqd, sizeof(irqd));
if (irqd.data == MPU_PM_EVENT_SUSPEND_PREPARE) {
//going to sleep
sleepEvent();
} else if (irqd.data == MPU_PM_EVENT_POST_SUSPEND) {
//waking up
wakeEvent();
}
ioctl(fd, MPU_PM_EVENT_HANDLED, 0);
}
void MPLSensor::sleepEvent()
{
VFUNC_LOG;
pthread_mutex_lock(&mMplMutex);
if (mEnabled != 0) {
mForceSleep = true;
mOldEnabledMask = mEnabled;
setPowerStates(0);
}
pthread_mutex_unlock(&mMplMutex);
}
void MPLSensor::wakeEvent()
{
VFUNC_LOG;
pthread_mutex_lock(&mMplMutex);
if (mForceSleep) {
setPowerStates((mOldEnabledMask | mEnabled));
}
mForceSleep = false;
pthread_mutex_unlock(&mMplMutex);
}
/** fill in the sensor list based on which sensors are configured.
* return the number of configured sensors.
* parameter list must point to a memory region of at least 7*sizeof(sensor_t)
* parameter len gives the length of the buffer pointed to by list
*/
int MPLSensor::populateSensorList(struct sensor_t *list, int len)
{
int numsensors;
if(len < 7*sizeof(sensor_t)) {
ALOGE("sensor list too small, not populating.");
return 0;
}
/* fill in the base values */
memcpy(list, sSensorList, sizeof (struct sensor_t) * 7);
/* first add gyro, accel and compass to the list */
/* fill in accel values */
unsigned short accelId = inv_get_accel_id();
if(accelId == 0)
{
ALOGE("Can not get accel id");
}
fillAccel(accelId, list);
/* fill in compass values */
unsigned short compassId = inv_get_compass_id();
if(compassId == 0)
{
ALOGE("Can not get compass id");
}
fillCompass(compassId, list);
/* fill in gyro values */
fillGyro(MPU_NAME, list);
if(mNineAxisEnabled)
{
numsensors = 7;
/* all sensors will be added to the list */
/* fill in orientation values */
fillOrientation(list);
/* fill in rotation vector values */
fillRV(list);
/* fill in gravity values */
fillGravity(list);
/* fill in Linear accel values */
fillLinearAccel(list);
} else {
/* no 9-axis sensors, zero fill that part of the list */
numsensors = 3;
memset(list+3, 0, 4*sizeof(struct sensor_t));
}
return numsensors;
}
void MPLSensor::fillAccel(unsigned char accel, struct sensor_t *list)
{
switch (accel) {
case ACCEL_ID_LIS331:
list[Accelerometer].maxRange = ACCEL_LIS331_RANGE;
list[Accelerometer].resolution = ACCEL_LIS331_RESOLUTION;
list[Accelerometer].power = ACCEL_LIS331_POWER;
break;
case ACCEL_ID_LIS3DH:
list[Accelerometer].maxRange = ACCEL_LIS3DH_RANGE;
list[Accelerometer].resolution = ACCEL_LIS3DH_RESOLUTION;
list[Accelerometer].power = ACCEL_LIS3DH_POWER;
break;
case ACCEL_ID_KXSD9:
list[Accelerometer].maxRange = ACCEL_KXSD9_RANGE;
list[Accelerometer].resolution = ACCEL_KXSD9_RESOLUTION;
list[Accelerometer].power = ACCEL_KXSD9_POWER;
break;
case ACCEL_ID_KXTF9:
list[Accelerometer].maxRange = ACCEL_KXTF9_RANGE;
list[Accelerometer].resolution = ACCEL_KXTF9_RESOLUTION;
list[Accelerometer].power = ACCEL_KXTF9_POWER;
break;
case ACCEL_ID_BMA150:
list[Accelerometer].maxRange = ACCEL_BMA150_RANGE;
list[Accelerometer].resolution = ACCEL_BMA150_RESOLUTION;
list[Accelerometer].power = ACCEL_BMA150_POWER;
break;
case ACCEL_ID_BMA222:
list[Accelerometer].maxRange = ACCEL_BMA222_RANGE;
list[Accelerometer].resolution = ACCEL_BMA222_RESOLUTION;
list[Accelerometer].power = ACCEL_BMA222_POWER;
break;
case ACCEL_ID_BMA250:
list[Accelerometer].maxRange = ACCEL_BMA250_RANGE;
list[Accelerometer].resolution = ACCEL_BMA250_RESOLUTION;
list[Accelerometer].power = ACCEL_BMA250_POWER;
break;
case ACCEL_ID_ADXL34X:
list[Accelerometer].maxRange = ACCEL_ADXL34X_RANGE;
list[Accelerometer].resolution = ACCEL_ADXL34X_RESOLUTION;
list[Accelerometer].power = ACCEL_ADXL34X_POWER;
break;
case ACCEL_ID_MMA8450:
list[Accelerometer].maxRange = ACCEL_MMA8450_RANGE;
list[Accelerometer].maxRange = ACCEL_MMA8450_RANGE;
list[Accelerometer].maxRange = ACCEL_MMA8450_RANGE;
break;
case ACCEL_ID_MMA845X:
list[Accelerometer].maxRange = ACCEL_MMA845X_RANGE;
list[Accelerometer].resolution = ACCEL_MMA845X_RESOLUTION;
list[Accelerometer].power = ACCEL_MMA845X_POWER;
break;
case ACCEL_ID_MPU6050:
list[Accelerometer].maxRange = ACCEL_MPU6050_RANGE;
list[Accelerometer].resolution = ACCEL_MPU6050_RESOLUTION;
list[Accelerometer].power = ACCEL_MPU6050_POWER;
break;
default:
ALOGE("unknown accel id -- accel params will be wrong.");
break;
}
}
void MPLSensor::fillCompass(unsigned char compass, struct sensor_t *list)
{
switch (compass) {
case COMPASS_ID_AK8975:
list[MagneticField].maxRange = COMPASS_AKM8975_RANGE;
list[MagneticField].resolution = COMPASS_AKM8975_RESOLUTION;
list[MagneticField].power = COMPASS_AKM8975_POWER;
break;
case COMPASS_ID_AMI30X:
list[MagneticField].maxRange = COMPASS_AMI30X_RANGE;
list[MagneticField].resolution = COMPASS_AMI30X_RESOLUTION;
list[MagneticField].power = COMPASS_AMI30X_POWER;
break;
case COMPASS_ID_AMI306:
list[MagneticField].maxRange = COMPASS_AMI306_RANGE;
list[MagneticField].resolution = COMPASS_AMI306_RESOLUTION;
list[MagneticField].power = COMPASS_AMI306_POWER;
break;
case COMPASS_ID_YAS529:
list[MagneticField].maxRange = COMPASS_YAS529_RANGE;
list[MagneticField].resolution = COMPASS_AMI306_RESOLUTION;
list[MagneticField].power = COMPASS_AMI306_POWER;
break;
case COMPASS_ID_YAS530:
list[MagneticField].maxRange = COMPASS_YAS530_RANGE;
list[MagneticField].resolution = COMPASS_YAS530_RESOLUTION;
list[MagneticField].power = COMPASS_YAS530_POWER;
break;
case COMPASS_ID_HMC5883:
list[MagneticField].maxRange = COMPASS_HMC5883_RANGE;
list[MagneticField].resolution = COMPASS_HMC5883_RESOLUTION;
list[MagneticField].power = COMPASS_HMC5883_POWER;
break;
case COMPASS_ID_MMC314X:
list[MagneticField].maxRange = COMPASS_MMC314X_RANGE;
list[MagneticField].resolution = COMPASS_MMC314X_RESOLUTION;
list[MagneticField].power = COMPASS_MMC314X_POWER;
break;
case COMPASS_ID_HSCDTD002B:
list[MagneticField].maxRange = COMPASS_HSCDTD002B_RANGE;
list[MagneticField].resolution = COMPASS_HSCDTD002B_RESOLUTION;
list[MagneticField].power = COMPASS_HSCDTD002B_POWER;
break;
case COMPASS_ID_HSCDTD004A:
list[MagneticField].maxRange = COMPASS_HSCDTD004A_RANGE;
list[MagneticField].resolution = COMPASS_HSCDTD004A_RESOLUTION;
list[MagneticField].power = COMPASS_HSCDTD004A_POWER;
break;
default:
ALOGE("unknown compass id -- compass parameters will be wrong");
}
}
void MPLSensor::fillGyro(const char* gyro, struct sensor_t *list)
{
if ((gyro != NULL) && (strcmp(gyro, "mpu3050") == 0)) {
list[Gyro].maxRange = GYRO_MPU3050_RANGE;
list[Gyro].resolution = GYRO_MPU3050_RESOLUTION;
list[Gyro].power = GYRO_MPU3050_POWER;
} else {
list[Gyro].maxRange = GYRO_MPU6050_RANGE;
list[Gyro].resolution = GYRO_MPU6050_RESOLUTION;
list[Gyro].power = GYRO_MPU6050_POWER;
}
return;
}
/* fillRV depends on values of accel and compass in the list */
void MPLSensor::fillRV(struct sensor_t *list)
{
/* compute power on the fly */
list[RotationVector].power = list[Gyro].power + list[Accelerometer].power
+ list[MagneticField].power;
list[RotationVector].resolution = .00001;
list[RotationVector].maxRange = 1.0;
return;
}
void MPLSensor::fillOrientation(struct sensor_t *list)
{
list[Orientation].power = list[Gyro].power + list[Accelerometer].power
+ list[MagneticField].power;
list[Orientation].resolution = .00001;
list[Orientation].maxRange = 360.0;
return;
}
void MPLSensor::fillGravity( struct sensor_t *list)
{
list[Gravity].power = list[Gyro].power + list[Accelerometer].power
+ list[MagneticField].power;
list[Gravity].resolution = .00001;
list[Gravity].maxRange = 9.81;
return;
}
void MPLSensor::fillLinearAccel(struct sensor_t *list)
{
list[Gravity].power = list[Gyro].power + list[Accelerometer].power
+ list[MagneticField].power;
list[Gravity].resolution = list[Accelerometer].resolution;
list[Gravity].maxRange = list[Accelerometer].maxRange;
return;
}