android系统之sensor学习

转自:http://blog.csdn.net/yunjinwang/article/details/8461711

Sensor作为Android系统的一个输入设备,对Android设备来说是必不可少的。Sensor主要包括G-Sensor、LightsSensor、ProximitySensor、TemperatureSensor等。这里主要对G-Sensor模块进行解析。


我的平台是AML8276,android系统是4.0.4,kernel是3.0,所用的gsensor是kionix_accel;
整个sensor的工作包括driver, HAL, framework(c/c++, java)和application层;
首先我们从驱动driver开始,然后一层层向上看;

一, 驱动层
在驱动层,内核需要增加和修改的部分包括:
     1,相应硬件模块驱动代码,包括两个文件,这里是 kionix_accel.h,  kionix_accel.c,分别将kionix_accel.h放到kernel/common/customer/include/linux/中,将kionix_accel.c放到kernel/customer/drivers/misc/中;
      2,编译目录( kernel/customer/drivers/misc/ )下的Makefie 和KConfig,在KConfig中增加:
     config SENSORS_KXTJ2
          tristate "KXTJ2 accelerometer sensor driver"
          depends on I2C
     help
       Say yes here to support Kionix's KXTJ2 accelerometer sensor
     在MakeFile 下增加:obj-$(CONFIG_SENSORS_KXTJ2)     += kionix_accel.o 
     3, 在平台编译配置文件中(也就是make menuconfig生成的),增加:CONFIG_SENSORS_KXTJ2=y------->指定编译到内核中,如果是m则编译成ko;
     4,在平台模块代码文件中(kernel/customer/ boards/board-m6g17-t069.c ),在相应的i2c配置中,增加此模块:
static struct i2c_board_info __initdata aml_i2c_bus_info_b[] = {
........
#ifdef CONFIG_SENSORS_KXTJ2
     {
          I2C_BOARD_INFO("kionix_accel",  KIONIX_ACCEL_I2C_ADDR),
          //.irq = INT_GPIO_1,
          .platform_data = (void *) &kionix_accel_pdata,    
     },
#endif
}
 经过以上几步操作以后,就可以将此模块驱动编译到内核中。

G-sensor driver工作的大致流程:系统开机后,内核会先加载i2c总线驱动,然后再加载设备驱动,在设备驱动中的init函数中通过调用i2c_add_driver(&kionix_accel_driver)注册i2c_driver;此函数将driver注册到i2c_bus_type的总线上,此总线的匹配规则是利用i2c_client的名称和i2c_driver中id_table中的名称作匹配。其中i2c_client是系统自动创建的, board-m6g17-t069.c文件中的结构变量 static struct i2c_board_info __initdata aml_i2c_bus_info_b中需要添加G-sensor的设备信息。
当匹配成功时,i2c_driver中的probe()函数开始执行。

module_init(kionix_accel_init)---->i2c_add_driver(&kionix_accel_driver)-----> static struct i2c_driver kionix_accel_driver = {
     .driver = {
          .name     = KIONIX_ACCEL_NAME,
          .owner     = THIS_MODULE,
     },
     .probe          = kionix_accel_probe,
     .remove          = __devexit_p(kionix_accel_remove),
     .id_table     = kionix_accel_id,
};
Probe()函数 kionix_accel_probe()主要完成以下功能:
1.从i2c_client结构中得到初始化信息
2.创建G-sensor的工作队列
2.注册input_device设备
3.读取Chip ID
4.设置寄存器,使能G-sensor
5.设置并启动中断
当G-sensor上报数据的时候会触发中断,然后在中断处理函数中提交一个报值的任务到队列中并禁止中断。
在工作队列中读数G-sensor的数据并上报到input子系统中,最后使能中断。

系统启动后,驱动会在/sys/class/input/inputX下生成相应的设备文件,里面name节点包含有相应的模块名;
shell@
capabilities
device
event4
id
modalias
name
phys
power
properties
subsystem
uevent
uniq
同时会在/dev/input/里面也会生成inputX的节点,它是用来实际读取数据的。

驱动在工作的时候,主要分两部分:数据的采集及上报、设备的控制;
1,数据的采集主要是指通过I2C从硬件设备读取相关的数据并把数据上报,读取数据有两种方式,一种是通过中断,当有数据时,设备会发出中断信号给驱动,驱动去采集,另一种就是采用定时器不断的去定时采集数据;由于sensor也属于输入设备( 还有TouchScreen,Keyboard,Mouse,Sensor等),所以上报的时候,也要报到linux kernel的输入子系统里面,上层通过相应的子系统设备节点读取数据。

上报数据的过程:static void report_abs(void)

                {
                     short x,y,z,tilt;
                     if(read_data(&x,&y,&z,&tilt) != 0) {
                     /* report the absulate sensor data to input device */
                     input_report_abs(idev, ABS_X, y);
                     input_report_abs(idev, ABS_Y, x);
                     input_report_abs(idev, ABS_Z, z);
                     input_sync(idev);
                }

2,设备的控制包括打开、关闭、设置参数和使能等,一般上层会通过ioctl方式来交互
二, HAL层

android的HAL层,相当于它的应用层中的驱动,HAL与内核硬件驱动密切相关,由于硬件模块的差别性,HAL代码的编写也各有差别,特别是关于sensor的HAL代码基本上都要自己去实现,但基本架构是一样的。
sensor的HAL结构基本分两部分,一部分是控制操作,一部分是数据操作;
1,首先在android\hardware\libhardware\include\hardware目录下,有sensors.h文件,定义了struct sensors_module_t(sensor模块对象结构,如get_list), struct sensor_t(具体sensor设备对象结构,如名字,类型), struct sensors_poll_device_t(每个设备操作数据结构,如激活、设置参数、poll等),   typedef struct sensors_event_t(sensor的事件结构,如类型、数据), 同时也定义了所有传感器的类型:
/**
* Sensor types
*/
#define SENSOR_TYPE_ACCELEROMETER       1
#define SENSOR_TYPE_MAGNETIC_FIELD      2
#define SENSOR_TYPE_ORIENTATION         3
#define SENSOR_TYPE_GYROSCOPE           4
#define SENSOR_TYPE_LIGHT               5
#define SENSOR_TYPE_PRESSURE            6
#define SENSOR_TYPE_TEMPERATURE         7   // deprecated
#define SENSOR_TYPE_PROXIMITY           8
#define SENSOR_TYPE_GRAVITY             9
#define SENSOR_TYPE_LINEAR_ACCELERATION 10
#define SENSOR_TYPE_ROTATION_VECTOR     11
#define SENSOR_TYPE_RELATIVE_HUMIDITY   12
#define SENSOR_TYPE_AMBIENT_TEMPERATURE 13

在android/hardware/amlogic/sendsors/aml_gsensor目录是特定平台实际HAL的代码存放的位置,当然也有的平台只会给一个so的文件,不给源码。
在sensor_aml.cpp中,首先要定义HAL_MODULE_INFO_SYM,这个是每个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: "Sensors module",
                author: "Amlogic",
                methods: &sensors_module_methods,
        },
        get_sensors_list: sensors__get_sensors_list,
};

static int sensors__get_sensors_list(struct sensors_module_t* module,
                                     struct sensor_t const** list)
{
    *list = sSensorList;
    return ARRAY_SIZE(sSensorList);
}

/* The SENSORS Module */
static const struct sensor_t sSensorList[] = {
        {      "BMA250 3-axis Accelerometer",
                "Bosch",
                1, SENSORS_ACCELERATION_HANDLE,
                SENSOR_TYPE_ACCELEROMETER,
          4.0f*9.81f,
          (4.0f*9.81f)/1024.0f,
          0.2f,
          0,
          { }
     },
#ifdef ENABLE_LIGHT_SENSOR
      { "Light sensor",
          "(none)",
          1, SENSORS_LIGHT_HANDLE,
          SENSOR_TYPE_LIGHT, 5000.0f, 1.0f, 1.0f, 20000,{ } },
#endif
};
可以看出在事先定义当前支持的sensor模块,android通过module->get_sensors_list获取。

获取module后,利用open_sensors();得到hw_device_t ==sensors_poll_device_t==sensors_poll_context_t->device mSensor结构对象,这个结构对象在初始化时会创建相应的sensor对象,且它们都是以SensorBase为基础类,
sensors_poll_context_t::sensors_poll_context_t()
{
    mSensors[aml_accel] = new GSensor();
    mPollFds[aml_accel].fd = mSensors[aml_accel]->getFd();
    mPollFds[aml_accel].events = POLLIN;
    mPollFds[aml_accel].revents = 0;


#ifdef ENABLE_LIGHT_SENSOR
    mSensors[aml_light] = new LightSensor();
    mPollFds[aml_light].fd = mSensors[aml_light]->getFd();
    mPollFds[aml_light].events = POLLIN;
    mPollFds[aml_light].revents = 0;
#endif
   
}
通过 mSensor 对象就可以调用 activate、setDelay、poll进行激活读取数据处理了。

mSensors[aml_accel] = new GSensor();
在创建GSensor对象时会对/sys/class/input/inputX目录下的name读取,通过对比名称判断当前sensor到底是在哪个目录并记录下path,在后面对设备进行设置,也就是控制部分会用到这个目录下的结点;
同时由于 GSensor 是继承sensorBase的,所以在构造sendsorBase的时候会找到相应的/dev下的inputX设备open得到设备fd,用于后面读取数据,也就是数据部分。

HAL层准备好后,最后会编译成一个库,这里为sensor.amlogic.so


三, Framework层
对于每一个模块,framework层是最复杂的,它涉及到java部分和C++部分,且根据功能,又可分为service部分和manager部分,它们之间是通过binder进行通信的。
frameworks/base/libs/gui/ISensorServer.cpp
class ISensorServer : public IInterface
{
public:
    DECLARE_META_INTERFACE(SensorServer);

    virtual Vector<Sensor> getSensorList() = 0;
    virtual sp<ISensorEventConnection> createSensorEventConnection() = 0;
};


在Android中,和Sensor相关的几个类是:
 SensorManager : 通过它实现系统对Sensor的相关调用。
 SensorEvent :对各个Sensor数据的封装,具体可以参考Android的开发文档。
 SensorEventListener :对Sensor数据的监视,一旦有数据,就会调相应的函数。
Sensor : 对Sensor的封装。


对于service部分: 它是负责与HAL层建立联系并处理实际数据的服务。
frameworks/base/services/sensorservice/sensorService.cpp , 它继承了public BnSensorServer
系统启动时会执行systemProcess,同时会加载sensorService.java进程,在sensorService.java的构造函数中调用JNI方法_sensor_control_init()。
sensorService.cpp中SensorService::onFirstRef()会被执行,会创建SensorDevice& dev(SensorDevice::getInstance())对象,通过SensorService::threadLoop()里就对各个sensor进行poll并将数据发送到对应的申请connection中connection->sendEvents(buffer, count, scratch);
SensorDevice是一个单一对象类,故SensorDevice::getInstance()会在同一进程中只保留一个对象,SensorDevice::SensorDevice()通过hardware.c中读取HAL层生成的sensor.amlogic.so库。






对于manager部分:它是负责给应用程序提供接口的,与sensorserivce通过binder进行交互数据与控制。
frameworks/base/core/java/android/hardware/SensorManager.java
frameworks/base/core/jni/android_hardware_SensorManager.cpp
frameworks/base/libs/gui/sensorManager.cpp

android_hardware_SensorManager.cpp:
static JNINativeMethod gMethods[] = {
    {"nativeClassInit", "()V",              (void*)nativeClassInit },
    {"sensors_module_init","()I",           (void*)sensors_module_init },
    {"sensors_module_get_next_sensor","(Landroid/hardware/Sensor;I)I",    (void*)sensors_module_get_next_sensor },
    {"sensors_create_queue",  "()I",        (void*)sensors_create_queue },
    {"sensors_destroy_queue", "(I)V",       (void*)sensors_destroy_queue },
    {"sensors_enable_sensor", "(ILjava/lang/String;II)Z",   (void*)sensors_enable_sensor },
    {"sensors_data_poll",  "(I[F[I[J)I",     (void*)sensors_data_poll },
};
sensors_module_init()---->SensorManager::getInstance();由于SensorManager也是单一对象类,这里生成实体对象;
sensors_create_queue()----->SensorManager& mgr.createEventQueue():
sp<SensorEventQueue> SensorManager::createEventQueue()
{
    sp<SensorEventQueue> queue;

    Mutex::Autolock _l(mLock);
    while (assertStateLocked() == NO_ERROR) {
        sp<ISensorEventConnection> connection =
                mSensorServer->createSensorEventConnection();
        if (connection == NULL) {
            // SensorService just died.
            LOGE("createEventQueue: connection is NULL. SensorService died.");
            continue;
        }
        queue = new SensorEventQueue(connection);
        break;
    }
    return queue;
}
通过创建一个connection来建立queuece,其实就是利用connection中与sensorService建立的channel:
mSensorChannel = mSensorEventConnection->getSensorChannel();

通过循环获取sensor list中的各个对象的属性:
sensors_module_get_next_sensor()------>sensorManager::getSensorList()----->SensorManager::assertStateLocked()---->mSensorServer->getSensorList()通过binder从sensorService获取sensorlist;

使能某一sensor对象:
sensors_enable_sensor()---->queue->enableSensor(sensor, delay)---->mSensorEventConnection->setEventRate(handle, us2ns(us))----->  通过ISensorEventConnection对象与sensorService:SensorEventConnection进行交互--------> SensorService::SensorEventConnection::enableDisable(int handle, bool enabled)---> SensorService::enable()---->mActiveConnections.add(connection)只是将connection加入到激活数组中,而并非直接使能或关闭硬件;


循环监听事件:
sensorChannel用一对pipe来sensorService到sensorEventQueue的事件信息。
sensors_data_poll()------->queue->read(&event, 1)---->mSensorChannel->read()- ---->通过pipe<------ SensorChannel::write()<---------mChannel->write() <----------SensorService::SensorEventConnection::sendEvents() <-------activeConnections[i]->sendEvents(buffer, count, scratch)<---------SensorService::threadLoop()


四, 应用层

      一个应用要实现Sensor的事件监听,要做到如下几步:
      1、定义要监控的Sensor。
          Sensor lightSensor = null;
          SensorManager sensormanager=null;
          sensormanager = (SensorManager)getSystemService(SENSOR_SERVICE);
          lightSensor = sensormanager.getDefaultSensor(Sensor.TYPE_LIGHT);

      2、实现SensorEvenetListener。

           private SensorEventListener mListener = new SensorEventListener() {

               public void onSensorChanged(SensorEvent event) {
                     ... ... 

                     if (event.sensor==lightSensor)
                    {
                         Log.i("", "Found light sensor");

                    }

                     ... ...
               }
          }

          public void onAccuracyChanged(Sensor sensor, int accuracy)  {
               // TODO Auto-generated method stub

             }
          };

      3、向系统注册SensorEventListener。一般在resume中进行注册。

           sensormanager= (SensorManager) getSystemService(Context.SENSOR_SERVICE);

           mSensor = (sensormanager.getSensorList(sensor)).get(0);

           sensormanager.registerListener(mListener, mSensor,SensorManager.SENSOR_DELAY_NORMAL);   

           用完之后,记得注销,一般在onStop的时候注销。

          sensormanager.unregisterListener(mListener);

       这样就可以用Sensor了,当sensor的数据发生变化时,就会传过来。


你可能感兴趣的:(android系统之sensor学习)