| /* |
| * Copyright (C) 2012 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. |
| */ |
| |
| #ifndef ANDROID_MPL_SENSOR_H |
| #define ANDROID_MPL_SENSOR_H |
| |
| #include <stdint.h> |
| #include <errno.h> |
| #include <sys/cdefs.h> |
| #include <sys/types.h> |
| #include <poll.h> |
| #include <utils/Vector.h> |
| #include <utils/KeyedVector.h> |
| #include "sensors.h" |
| #include "SensorBase.h" |
| #include "InputEventReader.h" |
| |
| #ifdef INVENSENSE_COMPASS_CAL |
| |
| #ifdef COMPASS_YAS53x |
| #warning "unified HAL for YAS53x" |
| #include "CompassSensor.IIO.primary.h" |
| #elif COMPASS_AMI306 |
| #warning "unified HAL for AMI306" |
| #include "CompassSensor.IIO.primary.h" |
| #else |
| #warning "unified HAL for MPU9150" |
| #include "CompassSensor.IIO.9150.h" |
| #endif |
| #else |
| #warning "unified HAL for AKM" |
| #include "CompassSensor.AKM.h" |
| #endif |
| |
| /*****************************************************************************/ |
| /* Sensors Enable/Disable Mask |
| *****************************************************************************/ |
| #define MAX_CHIP_ID_LEN (20) |
| |
| #define INV_THREE_AXIS_GYRO (0x000F) |
| #define INV_THREE_AXIS_ACCEL (0x0070) |
| #define INV_THREE_AXIS_COMPASS (0x0380) |
| #define INV_ALL_SENSORS (0x7FFF) |
| |
| #ifdef INVENSENSE_COMPASS_CAL |
| #define ALL_MPL_SENSORS_NP (INV_THREE_AXIS_ACCEL \ |
| | INV_THREE_AXIS_COMPASS \ |
| | INV_THREE_AXIS_GYRO) |
| #else |
| #define ALL_MPL_SENSORS_NP (INV_THREE_AXIS_ACCEL \ |
| | INV_THREE_AXIS_COMPASS \ |
| | INV_THREE_AXIS_GYRO) |
| #endif |
| |
| // bit mask of current active features (mFeatureActiveMask) |
| #define INV_COMPASS_CAL 0x01 |
| #define INV_COMPASS_FIT 0x02 |
| #define INV_DMP_QUATERNION 0x04 |
| #define INV_DMP_DISPL_ORIENTATION 0x08 |
| |
| /* Uncomment to enable Low Power Quaternion */ |
| //#define ENABLE_LP_QUAT_FEAT |
| |
| /* Uncomment to enable DMP display orientation |
| (within the HAL, see below for Java framework) */ |
| //#define ENABLE_DMP_DISPL_ORIENT_FEAT |
| |
| #ifdef ENABLE_DMP_DISPL_ORIENT_FEAT |
| /* Uncomment following to expose the SENSOR_TYPE_SCREEN_ORIENTATION |
| sensor type (DMP screen orientation) to the Java framework. |
| NOTE: |
| need Invensense customized |
| 'hardware/libhardware/include/hardware/sensors.h' to compile correctly. |
| NOTE: |
| need Invensense java framework changes to: |
| 'frameworks/base/core/java/android/view/WindowOrientationListener.java' |
| 'frameworks/base/core/java/android/hardware/Sensor.java' |
| 'frameworks/base/core/java/android/hardware/SensorEvent.java' |
| for the 'Auto-rotate screen' to use this feature. |
| */ |
| #define ENABLE_DMP_SCREEN_AUTO_ROTATION |
| #warning "ENABLE_DMP_DISPL_ORIENT_FEAT is defined, framework changes are necessary for HAL to work properly" |
| #endif |
| |
| int isDmpScreenAutoRotationEnabled() |
| { |
| #ifdef ENABLE_DMP_SCREEN_AUTO_ROTATION |
| return 1; |
| #else |
| return 0; |
| #endif |
| } |
| |
| int (*m_pt2AccelCalLoadFunc)(long *bias) = NULL; |
| |
| /*****************************************************************************/ |
| /** MPLSensor implementation which fits into the HAL example for crespo provided |
| * by Google. |
| * WARNING: there may only be one instance of MPLSensor, ever. |
| */ |
| |
| class MPLSensor: public SensorBase |
| { |
| typedef int (MPLSensor::*hfunc_t)(sensors_event_t*); |
| |
| public: |
| |
| enum { |
| Gyro = 0, |
| RawGyro, |
| Accelerometer, |
| MagneticField, |
| Orientation, |
| RotationVector, |
| LinearAccel, |
| Gravity, |
| NUMSENSORS |
| }; |
| |
| MPLSensor(CompassSensor *, int (*m_pt2AccelCalLoadFunc)(long*) = 0); |
| virtual ~MPLSensor(); |
| |
| virtual int setDelay(int32_t handle, int64_t ns); |
| virtual int enable(int32_t handle, int enabled); |
| int32_t getEnableMask() { return mEnabled; } |
| |
| virtual int readEvents(sensors_event_t *data, int count); |
| virtual int getFd() const; |
| virtual int getAccelFd() const; |
| virtual int getCompassFd() const; |
| virtual int getPollTime(); |
| virtual bool hasPendingEvents() const; |
| virtual void sleepEvent(); |
| virtual void wakeEvent(); |
| int populateSensorList(struct sensor_t *list, int len); |
| void cbProcData(); |
| |
| //static pointer to the object that will handle callbacks |
| static MPLSensor* gMPLSensor; |
| |
| //AKM HAL Integration |
| //void set_compass(long ready, long x, long y, long z, long accuracy); |
| int executeOnData(sensors_event_t* data, int count); |
| int readAccelEvents(sensors_event_t* data, int count); |
| int readCompassEvents(sensors_event_t* data, int count); |
| |
| int turnOffAccelFifo(); |
| int enableDmpOrientation(int); |
| int dmpOrientHandler(int); |
| int readDmpOrientEvents(sensors_event_t* data, int count); |
| int getDmpOrientFd(); |
| int openDmpOrientFd(); |
| int closeDmpOrientFd(); |
| |
| int getDmpRate(int64_t *); |
| int checkDMPOrientation(); |
| |
| protected: |
| CompassSensor *mCompassSensor; |
| |
| int gyroHandler(sensors_event_t *data); |
| int rawGyroHandler(sensors_event_t *data); |
| int accelHandler(sensors_event_t *data); |
| int compassHandler(sensors_event_t *data); |
| int rvHandler(sensors_event_t *data); |
| int laHandler(sensors_event_t *data); |
| int gravHandler(sensors_event_t *data); |
| int orienHandler(sensors_event_t *data); |
| void calcOrientationSensor(float *Rx, float *Val); |
| virtual int update_delay(); |
| |
| void inv_set_device_properties(); |
| int inv_constructor_init(); |
| int inv_constructor_default_enable(); |
| int setGyroInitialState(); |
| int setAccelInitialState(); |
| int masterEnable(int en); |
| int onPower(int en); |
| int enableLPQuaternion(int); |
| int enableQuaternionData(int); |
| int onDMP(int); |
| int enableGyro(int en); |
| int enableAccel(int en); |
| int enableCompass(int en); |
| void computeLocalSensorMask(int enabled_sensors); |
| int enableSensors(unsigned long sensors, int en, uint32_t changed); |
| int inv_read_gyro_buffer(int fd, short *data, long long *timestamp); |
| int inv_float_to_q16(float *fdata, long *ldata); |
| int inv_long_to_q16(long *fdata, long *ldata); |
| int inv_float_to_round(float *fdata, long *ldata); |
| int inv_float_to_round2(float *fdata, short *sdata); |
| int inv_read_temperature(long long *data); |
| int inv_read_dmp_state(int fd); |
| int inv_read_sensor_bias(int fd, long *data); |
| void inv_get_sensors_orientation(void); |
| int inv_init_sysfs_attributes(void); |
| #ifdef COMPASS_YAS53x |
| int resetCompass(void); |
| #endif |
| void setCompassDelay(int64_t ns); |
| void enable_iio_sysfs(void); |
| int enableTap(int); |
| int enableFlick(int); |
| int enablePedometer(int); |
| int checkLPQuaternion(); |
| |
| int mNewData; // flag indicating that the MPL calculated new output values |
| int mDmpStarted; |
| long mMasterSensorMask; |
| long mLocalSensorMask; |
| int mPollTime; |
| bool mHaveGoodMpuCal; // flag indicating that the cal file can be written |
| int mGyroAccuracy; // value indicating the quality of the gyro calibr. |
| int mAccelAccuracy; // value indicating the quality of the accel calibr. |
| int mCompassAccuracy; // value indicating the quality of the compass calibr. |
| struct pollfd mPollFds[5]; |
| int mSampleCount; |
| pthread_mutex_t mMplMutex; |
| pthread_mutex_t mHALMutex; |
| |
| char mIIOBuffer[(16 + 8 * 3 + 8) * IIO_BUFFER_LENGTH]; |
| |
| int iio_fd; |
| int accel_fd; |
| int mpufifo_fd; |
| int gyro_temperature_fd; |
| |
| int dmp_orient_fd; |
| int mDmpOrientationEnabled; |
| |
| uint32_t mEnabled; |
| uint32_t mOldEnabledMask; |
| sensors_event_t mPendingEvents[NUMSENSORS]; |
| int64_t mDelays[NUMSENSORS]; |
| hfunc_t mHandlers[NUMSENSORS]; |
| short mCachedGyroData[3]; |
| long mCachedAccelData[3]; |
| long mCachedCompassData[3]; |
| long mCachedQuaternionData[4]; |
| android::KeyedVector<int, int> mIrqFds; |
| |
| InputEventCircularReader mAccelInputReader; |
| InputEventCircularReader mGyroInputReader; |
| |
| bool mFirstRead; |
| short mTempScale; |
| short mTempOffset; |
| int64_t mTempCurrentTime; |
| int mAccelScale; |
| |
| uint32_t mPendingMask; |
| unsigned long mSensorMask; |
| |
| char chip_ID[MAX_CHIP_ID_LEN]; |
| |
| signed char mGyroOrientation[9]; |
| signed char mAccelOrientation[9]; |
| |
| int64_t mSensorTimestamp; |
| int64_t mCompassTimestamp; |
| |
| struct sysfs_attrbs { |
| char *chip_enable; |
| char *power_state; |
| char *dmp_firmware; |
| char *firmware_loaded; |
| char *dmp_on; |
| char *dmp_int_on; |
| char *dmp_event_int_on; |
| char *dmp_output_rate; |
| char *tap_on; |
| char *key; |
| char *self_test; |
| char *temperature; |
| |
| char *gyro_enable; |
| char *gyro_fifo_rate; |
| char *gyro_orient; |
| char *gyro_x_fifo_enable; |
| char *gyro_y_fifo_enable; |
| char *gyro_z_fifo_enable; |
| |
| char *accel_enable; |
| char *accel_fifo_rate; |
| char *accel_fsr; |
| char *accel_bias; |
| char *accel_orient; |
| char *accel_x_fifo_enable; |
| char *accel_y_fifo_enable; |
| char *accel_z_fifo_enable; |
| |
| char *quaternion_on; |
| char *in_quat_r_en; |
| char *in_quat_x_en; |
| char *in_quat_y_en; |
| char *in_quat_z_en; |
| |
| char *in_timestamp_en; |
| char *trigger_name; |
| char *current_trigger; |
| char *buffer_length; |
| |
| char *display_orientation_on; |
| char *event_display_orientation; |
| } mpu; |
| |
| char *sysfs_names_ptr; |
| int mFeatureActiveMask; |
| |
| private: |
| /* added for dynamic get sensor list */ |
| void fillAccel(const char* accel, struct sensor_t *list); |
| void fillGyro(const char* gyro, struct sensor_t *list); |
| void fillRV(struct sensor_t *list); |
| void fillOrientation(struct sensor_t *list); |
| void fillGravity(struct sensor_t *list); |
| void fillLinearAccel(struct sensor_t *list); |
| void storeCalibration(); |
| void loadDMP(); |
| bool isMpu3050(); |
| int isLowPowerQuatEnabled(); |
| int isDmpDisplayOrientationOn(); |
| |
| |
| }; |
| |
| extern "C" { |
| void setCallbackObject(MPLSensor*); |
| MPLSensor *getCallbackObject(); |
| } |
| |
| #endif // ANDROID_MPL_SENSOR_H |