sensor__HAl分析(实现)

首先是sensor这个模块的id定义,主要是实现了一个sensors_module_t结构:

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 = "MMA8451Q & AK8973A & gyro Sensors Module",
        .author = "The RKdroid Project",
        .methods = &sensors_module_methods,
    },
    .get_sensors_list = sensors__get_sensors_list
};

sensors__get_sensors_list函数返回这个平台的所有sensor

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

对应sSensorList是一个sensor_t的结构

static const struct sensor_t sSensorList[] = {
        { "MMA8452Q 3-axis Accelerometer",    
            	"Freescale Semiconductor",
                1, SENSORS_HANDLE_BASE+ID_A,
                SENSOR_TYPE_ACCELEROMETER, 4.0f*9.81f, (4.0f*9.81f)/256.0f, 0.2f, 0, { } },
        { "AK8975 3-axis Magnetic field sensor",
                "Asahi Kasei",
                1, SENSORS_HANDLE_BASE+ID_M,
                SENSOR_TYPE_MAGNETIC_FIELD, 2000.0f, 1.0f/16.0f, 6.8f, 0, { } },
        { "AK8975 Orientation sensor",
                "Asahi Kasei",
                1, SENSORS_HANDLE_BASE+ID_O,
                SENSOR_TYPE_ORIENTATION, 360.0f, 1.0f, 7.0f, 0, { } }, 

	{ "ST 3-axis Gyroscope sensor",
          "STMicroelectronics",
          1, SENSORS_HANDLE_BASE+ID_GY,
          SENSOR_TYPE_GYROSCOPE, RANGE_GYRO, CONVERT_GYRO, 6.1f, 1190, { } },
			
	{ "AL3006Proximity sensor",
		"Dyna Image Corporation",
		1, SENSORS_HANDLE_BASE+ID_P,
		SENSOR_TYPE_PROXIMITY,
		PROXIMITY_THRESHOLD_CM, PROXIMITY_THRESHOLD_CM,
		0.5f, 0, { } },
		
        { "AL3006 light sensor",
                "Dyna Image Corporation",
                1, SENSORS_HANDLE_BASE+ID_L,
                SENSOR_TYPE_LIGHT, 10240.0f, 1.0f, 0.5f, 0, { } },
};

这个是我手头上的这块板子所提供的sensor

open_sensors用来打开所有的sensor，并返回一个hw_device_t

static int open_sensors(const struct hw_module_t* module, const char* name,
        struct hw_device_t** device)
{
    return init_nusensors(module, device);
}

对应init_nusensors

int init_nusensors(hw_module_t const* module, hw_device_t** device)
{
	D("Entered.");
    int status = -EINVAL;

    sensors_poll_context_t *dev = new sensors_poll_context_t();
    memset(&dev->device, 0, sizeof(sensors_poll_device_t));

    dev->device.common.tag = HARDWARE_DEVICE_TAG;
    dev->device.common.version  = 0;
    dev->device.common.module   = const_cast<hw_module_t*>(module);
    dev->device.common.close    = poll__close;
    dev->device.activate        = poll__activate;
    dev->device.setDelay        = poll__setDelay;
    dev->device.poll            = poll__poll;

    *device = &dev->device.common;
    status = 0;
    return status;
}

首先new 了一个sensors_poll_context_t，然后设置device，并返回

对应new  sensors_poll_context_t我们看一下其实现

sensors_poll_context_t::sensors_poll_context_t()
{
	D("Entered.");
	
    mSensors[light] = new LightSensor();
    mPollFds[light].fd = mSensors[light]->getFd();
    mPollFds[light].events = POLLIN;
    mPollFds[light].revents = 0;

    mSensors[proximity] = new ProximitySensor();
    mPollFds[proximity].fd = mSensors[proximity]->getFd();
    mPollFds[proximity].events = POLLIN;
    mPollFds[proximity].revents = 0;
	

    mSensors[mma] = new MmaSensor();
    mPollFds[mma].fd = mSensors[mma]->getFd();
    mPollFds[mma].events = POLLIN;
    mPollFds[mma].revents = 0;

    mSensors[akm] = new AkmSensor();
    mPollFds[akm].fd = mSensors[akm]->getFd();
    mPollFds[akm].events = POLLIN;
    mPollFds[akm].revents = 0;

	mSensors[gyro] = new GyroSensor();
    mPollFds[gyro].fd = mSensors[gyro]->getFd();
    mPollFds[gyro].events = POLLIN;
    mPollFds[gyro].revents = 0;

    int wakeFds[2];
    int result = pipe(wakeFds);
    LOGE_IF(result<0, "error creating wake pipe (%s)", strerror(errno));
    fcntl(wakeFds[0], F_SETFL, 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;
}

mSensors是一个SensorBase类型的类，而mPollFds是一个pollfd的结构。

mSensors保存了各个打开的sensor,mPollFds用来监听sensor的时候用的。

我们以打开陀螺仪为例，看一下其打开过程

GyroSensor::GyroSensor()
    : SensorBase(GY_DEVICE_NAME, "gyro"),
      mEnabled(0),
      mInputReader(32)
{
    mPendingEvent.version = sizeof(sensors_event_t);
    mPendingEvent.sensor = ID_GY;
    mPendingEvent.type = SENSOR_TYPE_GYROSCOPE;
    mPendingEvent.gyro.status = SENSOR_STATUS_ACCURACY_HIGH;
    memset(mPendingEvent.data, 0x00, sizeof(mPendingEvent.data));
	int err = 0;
    err = open_device();
	err = err<0 ? -errno : 0;
	if(err)
	{
		LOGD("%s:%s\n",__func__,strerror(-err));
		return;
	}
	
    int flags = 0;
    if (!ioctl(dev_fd, L3G4200D_IOCTL_GET_ENABLE, &flags)) {
        if (flags)  {
            mEnabled = 1;
        }
    }

    if (!mEnabled) {
        close_device();
    }
}

mPendingEvent是一个  sensors_event_t结构，首先对其sensor、type等赋值，然后调用open_device打开陀螺仪设备，然后调用ioctlL3G4200D_IOCTL_GET_ENABLE查看sensor是否启用

注意这里不要忽略了SensorBase(GY_DEVICE_NAME, "gyro")

我们看一下它做了什么。

这里GY_DEVICE_NAME对应"/dev/gyrosensor"

SensorBase::SensorBase(
        const char* dev_name,
        const char* data_name)
    : dev_name(dev_name), data_name(data_name),
      dev_fd(-1), data_fd(-1)
{
    data_fd = openInput(data_name);
}

设置dev_name和data_name后调用openInput打开设备

int SensorBase::openInput(const char* inputName) {
    int fd = -1;
    const char *dirname = "/dev/input";
    char devname[PATH_MAX];
    char *filename;
    DIR *dir;
    struct dirent *de;

    return getInput(inputName);
}

再继续看一下getInput

static int getInput(const char *inputName)
{
    int fd = -1;
    unsigned i;
    static bool first = true;
    static struct input_dev dev[255];

    if (first) {
        int fd = -1;
        const char *dirname = "/dev/input";
        char devname[PATH_MAX];
        char *filename;
        DIR *dir;
        struct dirent *de;

        first = false;
        for (i = 0; i < sizeof(dev)/sizeof(dev[0]); i++) {
            dev[i].fd = -1;
            dev[i].name[0] = '\0';
        }
        i = 0;

        dir = opendir(dirname);
        if (dir == NULL)
            return -1;
        strcpy(devname, dirname);
        filename = devname + strlen(devname);
        *filename++ = '/';
        while ((de = readdir(dir))) {
            if (de->d_name[0] == '.' &&
                (de->d_name[1] == '\0' || (de->d_name[1] == '.' && de->d_name[2] == '\0')))
                    continue;
            strcpy(filename, de->d_name);
            fd = open(devname, O_RDONLY);
            if (fd >= 0) {
                char name[80];
                if (ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) >= 1) {
                    dev[i].fd = fd;
                    strncpy(dev[i].name, name, sizeof(dev[i].name));
                }
            }
            i++;
        }
        closedir(dir);
    }

    for (i = 0; i < sizeof(dev)/sizeof(dev[0]); i++) {
        if (!strncmp(inputName, dev[i].name, sizeof(dev[i].name))) {
            fd = dev[i].fd;
            break;
        }
    }
    LOGE_IF(fd < 0, "couldn't find '%s' input device", inputName);

    return fd;
}

这个函数的作用就是打开"/dev/input"，查找其中的输入设备名字与传入参数匹配的那一个，这里是"gyro"，并返回相应的打开句柄。

再回到open_device

int SensorBase::open_device() {
    if (dev_fd<0 && dev_name) {
        dev_fd = open(dev_name, O_RDONLY);
        if(dev_fd<0)
        {
			LOGD("Couldn't open %s (%s)", dev_name, strerror(errno));
			return -errno;
        }
        
    }
    return 0;
}

这里只是简单的打开设备，对应"/dev/gyrosensor"

 

这样，再回到sensors_poll_context_t的构造函数，就把各个sensor设备都打开了，注意这里的mPollFds. Fd是data_fd，即打开“/dev/input/*”设备的句柄

到这里，sensor就已经打开了。

再看一下其它的函数。

Activate、setDelay都是直接调用相应的sensor接口直接调用相应sensor的接口，主要是pollEvents

int sensors_poll_context_t::pollEvents(sensors_event_t* data, int count)
{
	D("Entered : count = %d", count);
    int nbEvents = 0;
    int n = 0;

    do {
        // see if we have some leftover from the last poll()
        for (int i=0 ; count && i<numSensorDrivers ; i++) {//调用各个sensor的readEvents读取数据
            SensorBase* const sensor(mSensors[i]);
            if ((mPollFds[i].revents & POLLIN) || (sensor->hasPendingEvents())) {
                int nb = sensor->readEvents(data, count);	// num of evens received.
				D("nb = %d.", nb);
                if (nb < count) {
                    // no more data for this sensor
                    mPollFds[i].revents = 0;
                }
                count -= nb;
                nbEvents += nb;
                data += nb;
				D("count = %d, nbEvents = %d, data = 0x%p.", count, nbEvents, data);
            }
        }

        if (count) {
            // we still have some room, so try to see if we can get
            // some events immediately or just wait if we don't have
            // anything to return
            n = poll(mPollFds, numFds, nbEvents ? 0 : -1);
            if (n<0) {
                LOGE("poll() failed (%s)", strerror(errno));
                return -errno;
            }
            if (mPollFds[wake].revents & POLLIN) {
                char msg;
                int result = read(mPollFds[wake].fd, &msg, 1);
                LOGE_IF(result<0, "error reading from wake pipe (%s)", strerror(errno));
                LOGE_IF(msg != WAKE_MESSAGE, "unknown message on wake queue (0x%02x)", int(msg));
                mPollFds[wake].revents = 0;
            }
        }
        // if we have events and space, go read them
		D("n =0x%x, count = 0x%x.", n, count);
    } while (n && count);

	D("to return : nbEvents = %d", nbEvents);
    return nbEvents;
}

我们这里看一下GyroSensor的readEvents

int GyroSensor::readEvents(sensors_event_t* data, int count)
{
    //LOGD("*******************Gyro readEvents");
    //LOGD("count: %d, mHasPendingEvent: %d", count, mHasPendingEvent);
    static int64_t prev_time;
    int64_t time;

    if (count < 1)
        return -EINVAL;

    if (mHasPendingEvent) {
        mHasPendingEvent = false;
        mPendingEvent.timestamp = getTimestamp();
        *data = mPendingEvent;
        return mEnabled ? 1 : 0;
    }

    ssize_t n = mInputReader.fill(data_fd);//从输入设备中读取数据
    if (n < 0)
        return n;

    int numEventReceived = 0;
    input_event const* event;
    float gyrox = 0, gyroy = 0, gyroz = 0;

#if FETCH_FULL_EVENT_BEFORE_RETURN
again:
#endif
    while (count && mInputReader.readEvent(&event)) {//读取当前一个event，返回还有的数据大小

        //LOGD("GyroSensor::readEvents() coutn = %d, event->value = %f", count, event->value);
        int type = event->type;
        if (type == EV_REL) {//为事件相对坐标
            float value = event->value;
            if (event->code == EVENT_TYPE_GYRO_X) {
                gyrox = value;
            } else if (event->code == EVENT_TYPE_GYRO_Y) {
                gyroy = value;
            } else if (event->code == EVENT_TYPE_GYRO_Z) {
                gyroz = value;
            }

	    NineAxisTypeDef nineInput;
            nineInput.ax =  1;
            nineInput.ay =  1;
            nineInput.az =  1000;
            nineInput.mx =  300;
            nineInput.my =  300;
            nineInput.mz =  300;
            nineInput.gx =  gyrox;
            nineInput.gy =  gyroy;
            nineInput.gz =  gyroz;

            nineInput.time = getTimestamp()/1000000;

            FusionTypeDef fusionData = MEMSAlgLib_Fusion_Update(nineInput);
            float offx, offy, offz;
            MEMSAlgLib_Fusion_Get_GyroOffset(&offx,&offy,&offz);
            //LOGD("gyro offset: %f, %f, %f", offx, offy, offz);
            mPendingEvent.data[0] = (gyrox-offx) * CONVERT_GYRO_X;
            mPendingEvent.data[1] = (gyroy-offy) * CONVERT_GYRO_Y;
            mPendingEvent.data[2] = (gyroz-offz) * CONVERT_GYRO_Z;

	    mPendingEvent.gyro.x =  mPendingEvent.data[0];
            mPendingEvent.gyro.y =  mPendingEvent.data[1];
            mPendingEvent.gyro.z =  mPendingEvent.data[2];
	    //LOGD("mPendingEvent: %f, %f, %f", mPendingEvent.gyro.x, mPendingEvent.gyro.y, mPendingEvent.gyro.z);
        }else if (type == EV_SYN) {//表示Motion的一系列动作结束
           
            time = timevalToNano(event->time);
            if(mEnabled) {
                mPendingEvent.timestamp = time;

                *data++ = mPendingEvent;
                count--;
                numEventReceived++;
            }

        }else {
            LOGE("GyroSensor: unknown event (type=%d, code=%d)", type, event->code);
        }
        mInputReader.next();
    }

#if FETCH_FULL_EVENT_BEFORE_RETURN
    /* if we didn't read a complete event, see if we can fill and
       try again instead of returning with nothing and redoing poll. */
    if (numEventReceived == 0 && mEnabled == 1) {
        n = mInputReader.fill(data_fd);
        if (n)
            goto again;
    }
#endif

    return numEventReceived;
}

这里看一下mInputReader，是一个InputEventCircularReader结构，表示的是一个环形的读入数据缓冲区

ssize_t InputEventCircularReader::fill(int fd)
{
    size_t numEventsRead = 0;
    if (mFreeSpace) {
        const ssize_t nread = read(fd, mHead, mFreeSpace * sizeof(input_event));//读取数据
        if (nread<0 || nread % sizeof(input_event)) {
            // we got a partial event!!
            return nread<0 ? -errno : -EINVAL;
        }

        numEventsRead = nread / sizeof(input_event);
        // dumpEvents(mHead, numEventsRead);
        D("nread = %ld, numEventsRead = %d.", nread, numEventsRead);
        if (numEventsRead) {
            mHead += numEventsRead;
            mFreeSpace -= numEventsRead;
            if (mHead > mBufferEnd) {
                size_t s = mHead - mBufferEnd;
                memcpy(mBuffer, mBufferEnd, s * sizeof(input_event));
                mHead = mBuffer + s;
            }
        }
    }

    return numEventsRead;
}

mCurr表示未读事件的第一个，初始为缓冲区首部

Fill函数是把调用read从相应的输入设备读入数据mHead位置

readEvent函数返回mCurr和剩余的数据大小

next函数让mCurr移一个input_event

到这里,sensor HAL层就分析完了