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层就分析完了