Android sensor架构分析

  一.其主要框架如下图所示：

 
 
二.sensor的JNI层:android_hardware_SensorManager.cpp (frameworks\base\core\jni)
注册JNI:
    register_android_hardware_SensorManager
        jniRegisterNativeMethods(env, "android/hardware/SystemSensorManager", gSystemSensorManagerMethods, NELEM(gSystemSensorManagerMethods));           
        jniRegisterNativeMethods(env, "android/hardware/SystemSensorManager$BaseEventQueue", gBaseEventQueueMethods, NELEM(gBaseEventQueueMethods));
 
static JNINativeMethod gSystemSensorManagerMethods[] = {
            (void*)nativeClassInit },
                    nativeClassInit  ：这函数的作用
                        jclass sensorClass = _env->FindClass("android/hardware/Sensor"); //得到Sensor.java (frameworks\base\core\java\android\hardware)的class引用
                        sensorOffsets.name        = _env->GetFieldID(sensorClass, "mName",      "Ljava/lang/String;"); //得到sensor的的引用值，这里应该是可以直接把数据传递到framework
                        sensorOffsets.vendor      = _env->GetFieldID(sensorClass, "mVendor",    "Ljava/lang/String;");
                        sensorOffsets.version     = _env->GetFieldID(sensorClass, "mVersion",   "I");
 
            (void*)nativeGetNextSensor }, 
                    size_t count = mgr.getSensorList(&sensorList); //得到sensor列表，返回sensor个数
                        *list = mSensorList; //在SensorManager.cpp (frameworks\native\libs\gui)中
                        return mSensors.size();
                    env->SetObjectField(sensor, sensorOffsets.name,      name);  //获得sensor的信息，就是nativeClassInit 中需要得到的
                    env->SetObjectField(sensor, sensorOffsets.vendor,    vendor);
};
 
static JNINativeMethod gBaseEventQueueMethods[] = {
            (void*)nativeInitSensorEventQueue },
                 sp<SensorEventQueue> queue(mgr.createEventQueue()); 
                        queue = new SensorEventQueue(connection); //构造SensorEventQueue
                               mRecBuffer = new ASensorEvent[MAX_RECEIVE_BUFFER_EVENT_COUNT]; //生成一些ASensorEvent，用了记录sensor的信息
                 android_os_MessageQueue_getMessageQueue //得到_MessageQueue
            (void*)nativeEnableSensor },
                    receiver->getSensorEventQueue()->enableSensor(handle, rate_us, maxBatchReportLatency, reservedFlags); //enable sensor
                        enableSensor  //在SensorEventQueue.cpp (frameworks\native\libs\gui)中
                            mSensorEventConnection->enableDisable(handle, true, us2ns(samplingPeriodUs), us2ns(maxBatchReportLatencyUs), reservedFlags); 
                                    
            (void*)nativeDisableSensor }, //关闭sensor
 
            (void*)nativeDestroySensorEventQueue },
 
            (void*)nativeFlushSensor },
};
 
    实现SensorManager.java中的native函数，它主要调用SenrsorManager.cpp和SensorEventQueue.cpp中的类来完成相关的工作。
   SenrsorManager.cpp与SensorService.cpp主要以binder通信
 
 

三.SensorService.cpp

       SensorService作为一个轻量级的system service，它运行于SystemServer内，即在system_init<system_init.cpp>调用SensorService::instantiate();

      SensorService主要功能如下：
          1) SensorService::instantiate创建实例对象，并增加到ServiceManager中，且创建并启动线程，并执行threadLoop
          2) threadLoop从sensor驱动获取原始数据，然后通过SensorEventConnection把事件发送给客户端
          3) BnSensorServer的成员函数负责让客户端获取sensor列表和创建SensorEventConnection

 在addService时，第一次构建sp强引用对象时，会调用onFirstRef函数 
void SensorService::onFirstRef()  
       SensorDevice& dev(SensorDevice::getInstance()); // 获取SensorDevice实例， 也就是调用下面的SensorDevice::SensorDevice()。    
      ssize_t count = dev.getSensorList(&list);  调用SensorDevice.getSensorList获取sensor_t列表 
     //虚拟的sensor，也就是没有硬件，通过其他硬件计算出来的。
        uint32_t virtualSensorsNeeds = (1<<SENSOR_TYPE_GRAVITY) | (1<<SENSOR_TYPE_LINEAR_ACCELERATION) | (1<<SENSOR_TYPE_ROTATION_VECTOR); 
        registerSensor( new HardwareSensor(list[i]) ); //根据硬件sensor_t创建HardwareSensor,然后加入mSensorList(Sensor),和mSensorMap(HardwareSensor)中 
        mUserSensorList = mSensorList; // build the sensor list returned to users
        /* 这里加入的前提是hasGyro，也就是需要陀螺仪 ,才能加入虚拟sensor*/
         aSensor = registerVirtualSensor( new RotationVectorSensor() );   //根据硬件sensor_t创建对应的senosr(如GravitySensor), 根据硬件sensor_t创建对应的senosr(如GravitySensor), 
         if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {
                    mUserSensorList.add(aSensor);     //加入UserSensorList，这里RotationVectorSensor，GravitySensor，LinearAccelerationSensor， OrientationSensor， CorrectedGyroSensor
           }
        / *后面有一些关于batching的sensor的设置，batching sensor也就是支持批处理的sensor，有fifo */
         Looper = new Looper(false);  //消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper
        mSensorEventBuffer = new sensors_event_t[minBufferSize]; //sensors_event用于藏消息
        mSensorEventScratch = new sensors_event_t[minBufferSize];
        run("SensorService", PRIORITY_URGENT_DISPLAY); // run("SensorService", PRIORITY_URGENT_DISPLAY);运行线程，并执行threadLoop
 
 
bool SensorService::threadLoop()
    ssize_t count = device.poll(mSensorEventBuffer, numEventMax);  //调用SensorDevice.poll获取sensors_event_t事件 
  fusion.process(event[i]);对每一个事件，执行SensorFusion.process 
   activeConnections[i]->sendEvents(mSensorEventBuffer, count, mSensorEventScratch, mMapFlushEventsToConnections); 调用SensorService::SensorEventConnection::sendEvents，把事件发送给所有的listener
 
status_t SensorService::SensorEventConnection::enableDisable
    err = mService->enable(this, handle, samplingPeriodNs, maxBatchReportLatencyNs,  reservedFlags);
        SensorService::enable
            err = sensor->activate(connection.get(), true); //使能sensor
 
 
 
 
四.sensor上层调用中间层的入口
SensorDevice.cpp (frameworks\native\services\sensorservice)
 

SensorDevice::SensorDevice()

    1.hw_get_module(SENSORS_HARDWARE_MODULE_ID, (hw_module_t const**)&mSensorModule); //这个在Sensors.c (vendor\mediatek\proprietary\hardware\sensor)
  
  2.err = sensors_open_1(&mSensorModule->common, &mSensorDevice); 打开sensor
   
3.err = pressure_sensors_open(&mSensorDevicePressure); //这里我们加入的温度气压传感器
  
  4. mSensorModule->get_sensors_list(mSensorModule, &list); //得到sensor列表，Sensors.c (vendor\mediatek\proprietary\hardware\sensor)
  
  5.for (i=0; i<size_t(count-PRES_TEMP_SENSORS_CNT); i++) {
                 mActivationCount.add(list[i].handle, model); //把sensor加入到一个vector，handle是sensor唯一的标志 , Hwmsen_chip_info.c (vendor\mediatek\proprietary\hardware\sensor)
                mSensorDevice->activate(reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice), list[i].handle, 0);  //激活sensor
            }
    6.for (; i<size_t(count); i++) {
          mActivationCount.add(list[i].handle, model);
          mSensorDevicePressure->activate(mSensorDevicePressure, list[i].handle, 0);
 
 
sensor的重要结构体
        Sensor设备结构体sensors_poll_device_t，对标准硬件设备hw_device_t结构体的扩展，主要完成读取底层数据，并将数据存储在struct sensors_poll_device_t结构体中，poll函数用来获取底层数据，调用时将被阻塞定义如下：

struct sensors_poll_device_t {

struct hw_device_t common;

//Activate/deactivate one sensor

    int (*activate)(struct sensors_poll_device_t *dev,

            int handle, int enabled);

    //Set the delay between sensor events in nanoseconds for a given sensor.

    int (*setDelay)(struct sensors_poll_device_t *dev,

            int handle, int64_t ns);

    //获取数据

    int (*poll)(struct sensors_poll_device_t *dev,

            sensors_event_t* data, int count);

};

 
 

 

  1. typedef struct hw_device_t {  
  2.     /** tag must be initialized to HARDWARE_DEVICE_TAG */  
  3.     uint32_t tag;  
  4.   
  5.     /** version number for hw_device_t */  
  6.     uint32_t version;  
  7.   
  8.     /** reference to the module this device belongs to */  
  9.     struct hw_module_t* module;  
  10.   
  11.     /** padding reserved for future use */  
  12.     uint32_t reserved[12];  
  13.   
  14.     /** Close this device */  
  15.     int (*close)(struct hw_device_t* device);  
  16.   
  17. } hw_device_t;  
     
     
        
 
  1. typedef struct sensors_event_t {  
  2.     /* must be sizeof(struct sensors_event_t) */  
  3.     int32_t version;  
  4.   
  5.     /* sensor identifier */  
  6.     int32_t sensor;  
  7.   
  8.     /* sensor type */  
  9.     int32_t type;  
  10.   
  11.     /* reserved */  
  12.     int32_t reserved0;  
  13.   
  14.     /* time is in nanosecond */  
  15.     int64_t timestamp;  
  16.   
  17.     union {  
  18.         float           data[16];  
  19.   
  20.         /* acceleration values are in meter per second per second (m/s^2) */  
  21.         sensors_vec_t   acceleration;  
  22.   
  23.         /* magnetic vector values are in micro-Tesla (uT) */  
  24.         sensors_vec_t   magnetic;  
  25.   
  26.         /* orientation values are in degrees */  
  27.         sensors_vec_t   orientation;  
  28.   
  29.         /* gyroscope values are in rad/s */  
  30.         sensors_vec_t   gyro;  
  31.   
  32.         /* temperature is in degrees centigrade (Celsius) */  
  33.         float           temperature;  
  34.   
  35.         /* distance in centimeters */  
  36.         float           distance;  
  37.   
  38.         /* light in SI lux units */  
  39.         float           light;  
  40.   
  41.         /* pressure in hectopascal (hPa) */  
  42.         float           pressure;  
  43.   
  44.         /* relative humidity in percent */  
  45.         float           relative_humidity;  
  46.     };  
  47.     uint32_t        reserved1[4];  
  48. } sensors_event_t;  
    来源： 
     
 
 
struct pollfd {
int fd;        /* 文件描述符 */
short events; /* 等待的事件 */
short revents; /* 实际发生了的事件 */
};
 
 
 
五.详解四中每一步
    第1步
.hw_get_module(SENSORS_HARDWARE_MODULE_ID, (hw_module_t const**)&mSensorModule); 
        根据SENSORS_HARDWARE_MODULE_ID得到Sensors.c (vendor\mediatek\proprietary\hardware\sensor)中的HAL层代码
            struct sensors_module_t HAL_MODULE_INFO_SYM = {
    .common = {
        .tag = HARDWARE_MODULE_TAG,  
        .version_major = 1,
        .version_minor = 0,
        .id = SENSORS_HARDWARE_MODULE_ID,
        .name = "MTK SENSORS Module",
        .author = "Mediatek",
        .methods = &sensors_module_methods,
    },
    .get_sensors_list = sensors__get_sensors_list,
};
 

这里主要函数是：
    sensors__get_sensors_list

        *list = sSensorList; //得到sensorlist
               struct sensor_t sSensorList[MAX_NUM_SENSOR] ={};   在Hwmsen_chip_info.c (vendor\mediatek\proprietary\hardware\sensor)中，我推测是apk判断是否支持某种sensor的依据 
               #ifdef CUSTOM_KERNEL_ACCELEROMETER   //这个与ProjectConfig.mk这个相对应
     {
        .name       = ACCELEROMETER,
        .vendor     = ACCELEROMETER_VENDER,
        .version    = 3,
.handle     = ID_ACCELEROMETER+ID_OFFSET,  //这个在Hwmsensor.h (kernel-3.10\include\linux)中定义，是标示各种sensor的唯一值，调用的时候使用
 
        .type       = SENSOR_TYPE_ACCELEROMETER,  //这个在Hwmsensor.h (kernel-3.10\include\linux)中定义，标示sensor的类型
        .maxRange   = ACCELEROMETER_RANGE,//32.0f,  
        .resolution = ACCELEROMETER_RESOLUTION,//4.0f/1024.0f ，上报的精度在4.0f---1024f
        .power      = ACCELEROMETER_POWER,//130.0f/1000.0f,  //估计上电用的时间
        .minDelay   = 10000, //最少的上报时间=10ms
.maxDelay   = 1000000, //1s,最大上报时间
        .reserved   = {}
     },
   #endif
 
 

第2步：

        
 
第3步：
    pressure_sensors_open(&mSensorDevicePressure); //这里我们加入的温度气压传感器
          sensors__open_sensors((struct hw_device_t**)device); //打开sensor
        sensors_poll_context_t *dev = new sensors_poll_context_t(); 
              mSensors[pre] = new PresSensor();
             
                   PresSensor::PresSensor() //进入构造函数
                        SensorBase(NULL, "lps331ap_prs") //在PresSensor.cpp (frameworks\native\services\sensorservice)
                               data_fd = openInput(data_name); //data_name = lps331ap_prs
                                       dir = opendir(dirname);  //dirname=/dev/input
                                       readdir(dir) //循环读取dir下每一个文件，找到lps331ap_prs这个文件，pressure_presence_flag = 1
                         
                    mEnabled(1),
                    mEnabledP(1),
                    mEnabledT(1),
                    currHzPollFreq(10.0f),
                    mInputReader(4)
                             mPendingEventP //设置mPendingEventP结构体，他一个sensors_event_t变量   
                   property_get("ro.hardware.accsensor", buffer, INPUT_SYSFS_PATH_PRES); //得到INPUT_SYSFS_PATH_PRES "/sys/class/input/input5/device/"
                   getCompenseParam(); //得到补偿参数
                        LPS331AP_InitializeLibrary(calvalues); //算法相关的
        dev->device.activate        = poll__activate; //填充结构体
        dev->device.setDelay        = poll__setDelay; 
        dev->device.poll            = poll__poll;
 
 
第4步：
    mSensorModule->get_sensors_list(mSensorModule, &list); //得到sensor列表，Sensors.c (vendor\mediatek\proprietary\hardware\sensor)
    
 
第5步：
 
 
第六步：
      6.for (; i<size_t(count); i++) {
          mActivationCount.add(list[i].handle, model); //把sensor加入到一个vector，handle是sensor唯一的标志 , Hwmsen_chip_info.c 
          mSensorDevicePressure->activate(mSensorDevicePressure, list[i].handle, 0);  
               dev->device.activate        = poll__activate; //在pressure_sensors_open里面赋值了这个函数指针
                    poll__activate //在Sensors.cpp (frameworks\native\services\sensorservice)中
                        ctx->activate(handle, enabled); //进行enable                   
                            sensors_poll_context_t::activate；在Sensors.cpp (frameworks\native\services\sensorservice)
                        index = handleToDriver(handle);       //这里返回0
                        err =  mSensors[index]->enable(handle, enabled);                        
                             PresSensor::enable      //在PresSensor.cpp (frameworks\native\services\sensorservice)中             
                                 fd = open(input_sysfs_path, O_RDWR); //打开/得到INPUT_SYSFS_PATH_PRES "/sys/class/input/input5/device/enable"
                                 err = write(fd, buf, sizeof(buf)); // 写入1，打开sensor
                         write(mWritePipeFd, &wakeMessage, 1);//写一个W到pipe,pipe在open的时候创建
    
创建pipe:Sensors.cpp (frameworks\native\services\sensorservice)的sensors_poll_context_t::sensors_poll_context_t()
    int wakeFds[2];
    int result = pipe(wakeFds);  //创建pipe
    ALOGE_IF(result<0, "error creating wake pipe (%s)", strerror(errno));
    fcntl(wakeFds[0], F_SETFL, O_NONBLOCK); //设置文件的flags为O_NONBLOCK
    fcntl(wakeFds[1], F_SETFL, O_NONBLOCK);
    mWritePipeFd = wakeFds[1]; //写管道
    mPollFds[wake].fd = wakeFds[0]; //读管道
    mPollFds[wake].events = POLLIN;
    mPollFds[wake].revents = 0;
 
 
 
6.sensor数据的读取
    
bool SensorService::threadLoop()  //
SensorService.cpp (frameworks\native\services\sensorservice)
            ssize_t count = device.poll(mSensorEventBuffer, numEventMax);
                    SensorDevice::poll(sensors_event_t* buffer, size_t count) //SensorDevice.cpp (frameworks\native\services\sensorservice)
                        c_pressure = mSensorDevicePressure->poll(mSensorDevicePressure, buffer, PRES_TEMP_SENSORS_CNT);
        //ALOGE( "SensorDevice::poll, mSensorDevicePressure return = %d\n", c_pressure);
        c = mSensorDevice->poll(reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice), buffer+PRES_TEMP_SENSORS_CNT, count-PRES_TEMP_SENSORS_CNT);
                                return ctx->pollEvents(data, count);  //Nusensors.cpp (vendor\mediatek\proprietary\hardware\sensor)
                                        int nb = sensor->readEvents(data, count);  //Sensors.cpp (frameworks\native\services\sensorservice)
                                                 int Hwmsen::readEvents(sensors_event_t* data, int count) //Hwmsen.cpp (vendor\mediatek\proprietary\hardware\sensor)
                                                        n = mInputReader.fill(mdata_fd);  //后面有些细节没有深究了
                                         n = poll(mPollFds, numFds, nbEvents ? 0 : -1);  //poll，等待事件
 
 
 
 
7.虚拟sensor的读取过程
注册过程
SensorService::onFirstRef
     ssize_t count = dev.getSensorList(&list); //得到sensorlist
    if (hasGyro) { //注册各种sensor
         aSensor = registerVirtualSensor( new RotationVectorSensor() );
                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {
                    mUserSensorList.add(aSensor);
                }
 
                aSensor = registerVirtualSensor( new GravitySensor(list, count) );
                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_GRAVITY)) {
                    mUserSensorList.add(aSensor);
                }
 
                aSensor = registerVirtualSensor( new LinearAccelerationSensor(list, count) );
                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_LINEAR_ACCELERATION)) {
                    mUserSensorList.add(aSensor);
                }
 
                aSensor = registerVirtualSensor( new OrientationSensor() );
                if (virtualSensorsNeeds & (1<<SENSOR_TYPE_ROTATION_VECTOR)) {
                    // if we are doing our own rotation-vector, also add
                    // the orientation sensor and remove the HAL provided one.
                    mUserSensorList.replaceAt(aSensor, orientationIndex);
                }
 
                // virtual debugging sensors are not added to mUserSensorList
                registerVirtualSensor( new CorrectedGyroSensor(list, count) );
                registerVirtualSensor( new GyroDriftSensor() );       
}
 
enable过程
    //SensorService.cpp (frameworks\native\services\sensorservice)
    SensorService::enable
        SensorInterface* sensor = mSensorMap.valueFor(handle); //得到sensor的接口，虚拟sensor的interface
        mActiveVirtualSensors.add(handle, sensor);  //加入到mActiveVirtualSensors链
        err = sensor->activate(connection.get(), true); //调用active
        SensorFusion::activate(void* ident, bool enabled) //调用SensorFusion.cpp (frameworks\native\services\sensorservice)
             mSensorDevice.activate(ident, mAcc.getHandle(), enabled); //使能加速度传感器
            mSensorDevice.activate(ident, mMag.getHandle(), enabled); //使能磁传感器
            mSensorDevice.activate(ident, mGyro.getHandle(), enabled); //使能陀螺仪
                 SensorDevice::activate //SensorDevice.cpp (frameworks\native\services\sensorservice) //这里就是开始使能实体sensor
 
 
获取数据过程
    SensorService::threadLoop() //
        count = device.poll(mSensorEventBuffer, numEventMax); //这里获取实体sensor的数据
             // handle virtual sensors
            if (count && vcount) { //如果是虚拟sensor
                SensorFusion& fusion(SensorFusion::getInstance());
                fusion.isEnabled() //如果使能
                fusion.process(event[i]); //调用process
                  SensorFusion::process //调用SensorFusion.cpp (frameworks\native\services\sensorservice)，这里传入的是实体sensor获取来的数据
                     mFusion.handleGyro(vec3_t(event.data), dT); //处理各自的数据
             mFusion.handleMag(mag);
                    mFusion.handleAcc(acc); 
    SensorInterface* si = mActiveVirtualSensors.valueAt(j); //得到虚拟sensor的接口
    if (si->process(&out, event[i])) { //获取计算好的值
           mSensorEventBuffer[count + k] = out;}
         // record the last synthesized values
          recordLastValueLocked(&mSensorEventBuffer[count], k);
          // sort the buffer by time-stamps
          sortEventBuffer(mSensorEventBuffer, count); //给这些event排序
  activeConnections[i]->sendEvents(mSensorEventBuffer, count, mSensorEventScratch,），通过activeConnections发送到上层
 
注意：
如果加速度,磁传感器，陀螺仪的数据不正常可能导致虚拟传感器没有数据！！
 
 
posted @ 2020-11-24 17:30  luoyuna  阅读(1823)  评论(0)  编辑  收藏  举报