本文整理汇总了C++中EVIOCGABS函数的典型用法代码示例。如果您正苦于以下问题：C++ EVIOCGABS函数的具体用法？C++ EVIOCGABS怎么用？C++ EVIOCGABS使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了EVIOCGABS函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: main
int main (int argc, char **argv)
{
int fd, rd, i, j, k;
struct input_event ev[64];
int version;
unsigned short id[4];
unsigned long bit[EV_MAX][NBITS(KEY_MAX)];
char name[256] = "Unknown";
int abs[5];
if (argc < 2) {
printf("Usage: evtest /dev/input/eventX\n");
printf("Where X = input device number\n");
return 1;
}
if ((fd = open(argv[argc - 1], O_RDONLY)) < 0) {
perror("evtest");
return 1;
}
if (ioctl(fd, EVIOCGVERSION, &version)) {
perror("evtest: can't get version");
return 1;
}
printf("Input driver version is %d.%d.%d\n",
version >> 16, (version >> 8) & 0xff, version & 0xff);
ioctl(fd, EVIOCGID, id);
printf("Input device ID: bus 0x%x vendor 0x%x product 0x%x version 0x%x\n",
id[ID_BUS], id[ID_VENDOR], id[ID_PRODUCT], id[ID_VERSION]);
ioctl(fd, EVIOCGNAME(sizeof(name)), name);
printf("Input device name: \"%s\"\n", name);
memset(bit, 0, sizeof(bit));
ioctl(fd, EVIOCGBIT(0, EV_MAX), bit[0]);
printf("Supported events:\n");
for (i = 0; i < EV_MAX; i++)
if (test_bit(i, bit[0])) {
printf(" Event type %d (%s)\n", i, events[i] ? events[i] : "?");
if (!i) continue;
ioctl(fd, EVIOCGBIT(i, KEY_MAX), bit[i]);
for (j = 0; j < KEY_MAX; j++)
if (test_bit(j, bit[i])) {
printf(" Event code %d (%s)\n", j, names[i] ? (names[i][j] ? names[i][j] : "?") : "?");
if (i == EV_ABS) {
ioctl(fd, EVIOCGABS(j), abs);
for (k = 0; k < 5; k++)
if ((k < 3) || abs[k])
printf(" %s %6d\n", absval[k], abs[k]);
}
}
}
printf("Testing ... (interrupt to exit)\n");
while (1) {
rd = read(fd, ev, sizeof(struct input_event) * 64);
if (rd < (int) sizeof(struct input_event)) {
printf("yyy\n");
perror("\nevtest: error reading");
return 1;
}
for (i = 0; i < rd / sizeof(struct input_event); i++)
if (ev[i].type == EV_SYN) {
printf("Event: time %ld.%06ld, -------------- %s ------------\n",
ev[i].time.tv_sec, ev[i].time.tv_usec, ev[i].code ? "Config Sync" : "Report Sync" );
} else if (ev[i].type == EV_MSC && (ev[i].code == MSC_RAW || ev[i].code == MSC_SCAN)) {
printf("Event: time %ld.%06ld, type %d (%s), code %d (%s), value %02x\n",
ev[i].time.tv_sec, ev[i].time.tv_usec, ev[i].type,
events[ev[i].type] ? events[ev[i].type] : "?",
ev[i].code,
names[ev[i].type] ? (names[ev[i].type][ev[i].code] ? names[ev[i].type][ev[i].code] : "?") : "?",
ev[i].value);
} else {
printf("Event: time %ld.%06ld, type %d (%s), code %d (%s), value %d\n",
ev[i].time.tv_sec, ev[i].time.tv_usec, ev[i].type,
events[ev[i].type] ? events[ev[i].type] : "?",
ev[i].code,
names[ev[i].type] ? (names[ev[i].type][ev[i].code] ? names[ev[i].type][ev[i].code] : "?") : "?",
ev[i].value);
}
}
}示例2: Gamepad_detectDevices
void Gamepad_detectDevices() {
unsigned int numPaths;
char ** gamepadPaths;
bool duplicate;
unsigned int pathIndex, gamepadIndex;
struct stat statBuf;
struct Gamepad_device * deviceRecord;
struct Gamepad_devicePrivate * deviceRecordPrivate;
int fd;
char name[128];
char * description;
int evKeyBits[(KEY_CNT - 1) / sizeof(int) * 8 + 1];
int evAbsBits[(ABS_CNT - 1) / sizeof(int) * 8 + 1];
int bit;
struct input_id id;
if (!inited) {
return;
}
gamepadPaths = findGamepadPaths(&numPaths);
pthread_mutex_lock(&devicesMutex);
for (pathIndex = 0; pathIndex < numPaths; pathIndex++) {
duplicate = false;
for (gamepadIndex = 0; gamepadIndex < numDevices; gamepadIndex++) {
if (!strcmp(((struct Gamepad_devicePrivate *) devices[gamepadIndex]->privateData)->path, gamepadPaths[pathIndex])) {
duplicate = true;
break;
}
}
if (duplicate) {
free(gamepadPaths[pathIndex]);
continue;
}
if (!stat(gamepadPaths[pathIndex], &statBuf)) {
deviceRecord = (Gamepad_device*)malloc(sizeof(struct Gamepad_device));
deviceRecord->deviceID = nextDeviceID++;
deviceRecord->eventDispatcher = EventDispatcher_create(deviceRecord);
devices = (Gamepad_device**)realloc(devices, sizeof(struct Gamepad_device *) * (numDevices + 1));
devices[numDevices++] = deviceRecord;
fd = open(gamepadPaths[pathIndex], O_RDONLY, 0);
deviceRecordPrivate = (Gamepad_devicePrivate*)malloc(sizeof(struct Gamepad_devicePrivate));
deviceRecordPrivate->fd = fd;
deviceRecordPrivate->path = gamepadPaths[pathIndex];
memset(deviceRecordPrivate->buttonMap, 0xFF, sizeof(deviceRecordPrivate->buttonMap));
memset(deviceRecordPrivate->axisMap, 0xFF, sizeof(deviceRecordPrivate->axisMap));
deviceRecord->privateData = deviceRecordPrivate;
if (ioctl(fd, EVIOCGNAME(sizeof(name)), name) > 0) {
description = (char*)malloc(strlen(name + 1));
strcpy(description, name);
} else {
description = (char*)malloc(strlen(gamepadPaths[pathIndex] + 1));
strcpy(description, gamepadPaths[pathIndex]);
}
deviceRecord->description = description;
if (!ioctl(fd, EVIOCGID, &id)) {
deviceRecord->vendorID = id.vendor;
deviceRecord->productID = id.product;
} else {
deviceRecord->vendorID = deviceRecord->productID = 0;
}
memset(evKeyBits, 0, sizeof(evKeyBits));
memset(evAbsBits, 0, sizeof(evAbsBits));
ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(evKeyBits)), evKeyBits);
ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(evAbsBits)), evAbsBits);
deviceRecord->numAxes = 0;
for (bit = 0; bit < ABS_CNT; bit++) {
if (test_bit(bit, evAbsBits)) {
if (ioctl(fd, EVIOCGABS(bit), &deviceRecordPrivate->axisInfo[bit]) < 0 ||
deviceRecordPrivate->axisInfo[bit].minimum == deviceRecordPrivate->axisInfo[bit].maximum) {
continue;
}
deviceRecordPrivate->axisMap[bit] = deviceRecord->numAxes;
deviceRecord->numAxes++;
}
}
deviceRecord->numButtons = 0;
for (bit = BTN_MISC; bit < KEY_CNT; bit++) {
if (test_bit(bit, evKeyBits)) {
deviceRecordPrivate->buttonMap[bit - BTN_MISC] = deviceRecord->numButtons;
deviceRecord->numButtons++;
}
}
deviceRecord->axisStates = (float*)calloc(sizeof(float), deviceRecord->numAxes);
deviceRecord->buttonStates = (bool*)calloc(sizeof(bool), deviceRecord->numButtons);
Gamepad_eventDispatcher()->dispatchEvent(Gamepad_eventDispatcher(), GAMEPAD_EVENT_DEVICE_ATTACHED, deviceRecord);
pthread_create(&deviceRecordPrivate->thread, NULL, deviceThread, deviceRecord);
}
}
//.........这里部分代码省略.........
示例3: evio_get_joystick_status
int evio_get_joystick_status(evio_handle v, float *abs_x1, float *abs_y1,
float *abs_x2, float *abs_y2, int *buttons) {
struct input_absinfo absinfo;
int xax2, yax2;
evio *evp = (evio *) v;
int rc=0;
memset(&absinfo, 0, sizeof(absinfo));
*abs_x1 = 0;
*abs_y1 = 0;
*abs_x2 = 0;
*abs_y2 = 0;
*buttons = 0;
if (ioctl(evp->fd, EVIOCGABS(ABS_X), &absinfo) < 0) {
return 0;
} else {
rc |= 1;
*abs_x1 = evio_absinfo2float(&absinfo);
}
if (ioctl(evp->fd, EVIOCGABS(ABS_Y), &absinfo) < 0) {
return 0;
} else {
rc |= 1;
*abs_y1 = evio_absinfo2float(&absinfo);
}
switch (evp->devjoystick) {
case EVENTIO_JOYSTICK_LOGIF310:
xax2 = ABS_RX;
yax2 = ABS_RY;
break;
case EVENTIO_JOYSTICK_NYKO:
xax2 = ABS_Z;
yax2 = ABS_RZ;
break;
default:
case EVENTIO_JOYSTICK_STD:
xax2 = 0;
yax2 = 0;
break;
}
if (xax2 && yax2) {
if (ioctl(evp->fd, EVIOCGABS(xax2), &absinfo) < 0) {
return 0;
} else {
rc |= 1;
*abs_x2 = evio_absinfo2float(&absinfo);
}
if (ioctl(evp->fd, EVIOCGABS(yax2), &absinfo) < 0) {
return 0;
} else {
rc |= 1;
*abs_y2 = evio_absinfo2float(&absinfo);
}
}
if (ioctl(evp->fd, EVIOCGKEY(sizeof(evp->keystate)), evp->keystate) >= 0) {
#if 1
int btmp=0;
btmp |= evio_get_button_status(v, BTN_BACK, EVENTIO_BACK);
btmp |= evio_get_button_status(v, BTN_TASK, EVENTIO_TASK);
btmp |= evio_get_button_status(v, BTN_START, EVENTIO_START);
btmp |= evio_get_button_status(v, BTN_A, EVENTIO_GAMEPAD_A);
btmp |= evio_get_button_status(v, BTN_B, EVENTIO_GAMEPAD_B);
btmp |= evio_get_button_status(v, BTN_X, EVENTIO_GAMEPAD_X);
btmp |= evio_get_button_status(v, BTN_Y, EVENTIO_GAMEPAD_Y);
btmp |= evio_get_button_status(v, BTN_TL, EVENTIO_TL);
btmp |= evio_get_button_status(v, BTN_TR, EVENTIO_TR);
btmp |= evio_get_button_status(v, BTN_THUMBL, EVENTIO_THUMBL);
btmp |= evio_get_button_status(v, BTN_THUMBR, EVENTIO_THUMBR);
#else
int i, btmp=0;
for (i=0; i<31; i++) {
if (EVIO_TESTBIT(BTN_GAMEPAD+i, evp->keybit))
btmp |= (1 << i);
}
#endif
*buttons = btmp;
}
return rc;
}示例4: SDL_EVDEV_init_touchscreen
static int
SDL_EVDEV_init_touchscreen(SDL_evdevlist_item* item)
{
int ret, i;
char name[64];
struct input_absinfo abs_info;
if (!item->is_touchscreen)
return 0;
item->touchscreen_data = SDL_calloc(1, sizeof(*item->touchscreen_data));
if (item->touchscreen_data == NULL)
return SDL_OutOfMemory();
ret = ioctl(item->fd, EVIOCGNAME(sizeof(name)), name);
if (ret < 0) {
SDL_free(item->touchscreen_data);
return SDL_SetError("Failed to get evdev touchscreen name");
}
item->touchscreen_data->name = SDL_strdup(name);
if (item->touchscreen_data->name == NULL) {
SDL_free(item->touchscreen_data);
return SDL_OutOfMemory();
}
ret = ioctl(item->fd, EVIOCGABS(ABS_MT_POSITION_X), &abs_info);
if (ret < 0) {
SDL_free(item->touchscreen_data->name);
SDL_free(item->touchscreen_data);
return SDL_SetError("Failed to get evdev touchscreen limits");
}
item->touchscreen_data->min_x = abs_info.minimum;
item->touchscreen_data->max_x = abs_info.maximum;
item->touchscreen_data->range_x = abs_info.maximum - abs_info.minimum;
ret = ioctl(item->fd, EVIOCGABS(ABS_MT_POSITION_Y), &abs_info);
if (ret < 0) {
SDL_free(item->touchscreen_data->name);
SDL_free(item->touchscreen_data);
return SDL_SetError("Failed to get evdev touchscreen limits");
}
item->touchscreen_data->min_y = abs_info.minimum;
item->touchscreen_data->max_y = abs_info.maximum;
item->touchscreen_data->range_y = abs_info.maximum - abs_info.minimum;
ret = ioctl(item->fd, EVIOCGABS(ABS_MT_SLOT), &abs_info);
if (ret < 0) {
SDL_free(item->touchscreen_data->name);
SDL_free(item->touchscreen_data);
return SDL_SetError("Failed to get evdev touchscreen limits");
}
item->touchscreen_data->max_slots = abs_info.maximum + 1;
item->touchscreen_data->slots = SDL_calloc(
item->touchscreen_data->max_slots,
sizeof(*item->touchscreen_data->slots));
if (item->touchscreen_data->slots == NULL) {
SDL_free(item->touchscreen_data->name);
SDL_free(item->touchscreen_data);
return SDL_OutOfMemory();
}
for(i = 0; i < item->touchscreen_data->max_slots; i++) {
item->touchscreen_data->slots[i].tracking_id = -1;
}
ret = SDL_AddTouch(item->fd, /* I guess our fd is unique enough */
item->touchscreen_data->name);
if (ret < 0) {
SDL_free(item->touchscreen_data->slots);
SDL_free(item->touchscreen_data->name);
SDL_free(item->touchscreen_data);
return ret;
}
return 0;
}示例5: touchpad_init
static int
touchpad_init(struct touchpad_dispatch *touchpad,
struct evdev_device *device)
{
struct motion_filter *accel;
unsigned long prop_bits[INPUT_PROP_MAX];
struct input_absinfo absinfo;
unsigned long abs_bits[NBITS(ABS_MAX)];
bool has_buttonpad;
double width;
double height;
double diagonal;
touchpad->base.interface = &touchpad_interface;
touchpad->device = device;
/* Detect model */
touchpad->model = get_touchpad_model(device);
ioctl(device->fd, EVIOCGPROP(sizeof(prop_bits)), prop_bits);
has_buttonpad = TEST_BIT(prop_bits, INPUT_PROP_BUTTONPAD);
/* Configure pressure */
ioctl(device->fd, EVIOCGBIT(EV_ABS, sizeof(abs_bits)), abs_bits);
if (TEST_BIT(abs_bits, ABS_PRESSURE)) {
ioctl(device->fd, EVIOCGABS(ABS_PRESSURE), &absinfo);
configure_touchpad_pressure(touchpad,
absinfo.minimum,
absinfo.maximum);
}
/* Configure acceleration factor */
width = abs(device->abs.max_x - device->abs.min_x);
height = abs(device->abs.max_y - device->abs.min_y);
diagonal = sqrt(width*width + height*height);
/* Set default parameters */
touchpad->constant_accel_factor =
DEFAULT_CONSTANT_ACCEL_NUMERATOR / diagonal;
touchpad->min_accel_factor = DEFAULT_MIN_ACCEL_FACTOR;
touchpad->max_accel_factor = DEFAULT_MAX_ACCEL_FACTOR;
touchpad->hysteresis.margin_x =
diagonal / DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR;
touchpad->hysteresis.margin_y =
diagonal / DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR;
touchpad->hysteresis.center_x = 0;
touchpad->hysteresis.center_y = 0;
/* Configure acceleration profile */
accel = create_pointer_accelator_filter(touchpad_profile);
if (accel == NULL)
return -1;
touchpad->filter = accel;
/* Setup initial state */
touchpad->reset = 1;
memset(touchpad->motion_history, 0, sizeof touchpad->motion_history);
touchpad->motion_index = 0;
touchpad->motion_count = 0;
touchpad->state = TOUCHPAD_STATE_NONE;
touchpad->last_finger_state = 0;
touchpad->finger_state = 0;
touchpad->fsm.events = NULL;
touchpad->fsm.events_count = 0;
touchpad->fsm.events_len = 0;
touchpad->fsm.state = FSM_IDLE;
touchpad->fsm.timer.fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
touchpad->fsm.timer.source =
libinput_add_fd(touchpad->device->base.seat->libinput,
touchpad->fsm.timer.fd,
fsm_timeout_handler,
touchpad);
if (touchpad->fsm.timer.source == NULL) {
close(touchpad->fsm.timer.fd);
accel->interface->destroy(accel);
return -1;
}
/* Configure */
touchpad->fsm.enable = !has_buttonpad;
return 0;
}示例6: EV_ConfigJoystick
static SDL_bool EV_ConfigJoystick(STJoystick::STJoystickData* joystick, int fd)
{
int i, t;
unsigned long keybit[40];
unsigned long absbit[40];
unsigned long relbit[40];
/* See if this device uses the new unified event API */
if ( (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) >= 0) &&
(ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) >= 0) &&
(ioctl(fd, EVIOCGBIT(EV_REL, sizeof(relbit)), relbit) >= 0) ) {
joystick->hwdata->is_hid = SDL_TRUE;
/* Get the number of buttons, axes, and other thingamajigs */
for ( i=BTN_JOYSTICK; i < KEY_MAX; ++i ) {
if ( test_bit(i, keybit) ) {
#ifdef DEBUG_INPUT_EVENTS
printf("Joystick has button: 0x%x\n", i);
#endif
joystick->hwdata->key_map[i-BTN_MISC] =
joystick->nbuttons;
++joystick->nbuttons;
}
}
for ( i=BTN_MISC; i < BTN_JOYSTICK; ++i ) {
if ( test_bit(i, keybit) ) {
#ifdef DEBUG_INPUT_EVENTS
printf("Joystick has button: 0x%x\n", i);
#endif
joystick->hwdata->key_map[i-BTN_MISC] =
joystick->nbuttons;
++joystick->nbuttons;
}
}
for ( i=0; i<ABS_MAX; ++i ) {
/* Skip hats */
if ( i == ABS_HAT0X ) {
i = ABS_HAT3Y;
continue;
}
if ( test_bit(i, absbit) ) {
int values[5];
if ( ioctl(fd, EVIOCGABS(i), values) < 0 )
continue;
#ifdef DEBUG_INPUT_EVENTS
printf("Joystick has absolute axis: %x\n", i);
printf("Values = { %d, %d, %d, %d, %d }\n",
values[0], values[1],
values[2], values[3], values[4]);
#endif /* DEBUG_INPUT_EVENTS */
joystick->hwdata->abs_map[i] = joystick->naxes;
if ( values[1] == values[2] ) {
joystick->hwdata->abs_correct[i].used = 0;
} else {
joystick->hwdata->abs_correct[i].used = 1;
joystick->hwdata->abs_correct[i].coef[0] =
(values[2] + values[1]) / 2 - values[4];
joystick->hwdata->abs_correct[i].coef[1] =
(values[2] + values[1]) / 2 + values[4];
t = ((values[2] - values[1]) / 2 - 2 * values[4]);
if ( t != 0 ) {
joystick->hwdata->abs_correct[i].coef[2] = (1 << 29) / t;
} else {
joystick->hwdata->abs_correct[i].coef[2] = 0;
}
}
++joystick->naxes;
}
}
for ( i=ABS_HAT0X; i <= ABS_HAT3Y; i += 2 ) {
if ( test_bit(i, absbit) || test_bit(i+1, absbit) ) {
#ifdef DEBUG_INPUT_EVENTS
printf("Joystick has hat %d\n",(i-ABS_HAT0X)/2);
#endif
++joystick->nhats;
}
}
if ( test_bit(REL_X, relbit) || test_bit(REL_Y, relbit) ) {
++joystick->nballs;
}
/* Allocate data to keep track of these thingamajigs */
if ( joystick->nhats > 0 ) {
if ( allocate_hatdata(joystick) < 0 ) {
joystick->nhats = 0;
}
}
if ( joystick->nballs > 0 ) {
if ( allocate_balldata(joystick) < 0 ) {
joystick->nballs = 0;
}
}
}
return(joystick->hwdata->is_hid);
}示例7: Gamepad_detectDevices
//.........这里部分代码省略.........
continue;
}
duplicate = false;
for (gamepadIndex = 0; gamepadIndex < numDevices; gamepadIndex++) {
if (!strcmp(((struct Gamepad_devicePrivate *) devices[gamepadIndex]->privateData)->path, fileName)) {
duplicate = true;
break;
}
}
if (duplicate) {
continue;
}
fd = open(fileName, O_RDONLY, 0);
memset(evCapBits, 0, sizeof(evCapBits));
memset(evKeyBits, 0, sizeof(evKeyBits));
memset(evAbsBits, 0, sizeof(evAbsBits));
if (ioctl(fd, EVIOCGBIT(0, sizeof(evCapBits)), evCapBits) < 0 ||
ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(evKeyBits)), evKeyBits) < 0 ||
ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(evAbsBits)), evAbsBits) < 0) {
close(fd);
continue;
}
if (!test_bit(EV_KEY, evCapBits) || !test_bit(EV_ABS, evCapBits) ||
!test_bit(ABS_X, evAbsBits) || !test_bit(ABS_Y, evAbsBits) ||
(!test_bit(BTN_TRIGGER, evKeyBits) && !test_bit(BTN_A, evKeyBits) && !test_bit(BTN_1, evKeyBits))) {
close(fd);
continue;
}
deviceRecord = malloc(sizeof(struct Gamepad_device));
deviceRecord->deviceID = nextDeviceID++;
devices = realloc(devices, sizeof(struct Gamepad_device *) * (numDevices + 1));
devices[numDevices++] = deviceRecord;
deviceRecordPrivate = malloc(sizeof(struct Gamepad_devicePrivate));
deviceRecordPrivate->fd = fd;
deviceRecordPrivate->path = malloc(strlen(fileName) + 1);
strcpy(deviceRecordPrivate->path, fileName);
memset(deviceRecordPrivate->buttonMap, 0xFF, sizeof(deviceRecordPrivate->buttonMap));
memset(deviceRecordPrivate->axisMap, 0xFF, sizeof(deviceRecordPrivate->axisMap));
deviceRecord->privateData = deviceRecordPrivate;
if (ioctl(fd, EVIOCGNAME(sizeof(name)), name) > 0) {
description = malloc(strlen(name) + 1);
strcpy(description, name);
} else {
description = malloc(strlen(fileName) + 1);
strcpy(description, fileName);
}
deviceRecord->description = description;
if (!ioctl(fd, EVIOCGID, &id)) {
deviceRecord->vendorID = id.vendor;
deviceRecord->productID = id.product;
} else {
deviceRecord->vendorID = deviceRecord->productID = 0;
}
memset(evKeyBits, 0, sizeof(evKeyBits));
memset(evAbsBits, 0, sizeof(evAbsBits));
ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(evKeyBits)), evKeyBits);
ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(evAbsBits)), evAbsBits);
deviceRecord->numAxes = 0;
for (bit = 0; bit < ABS_CNT; bit++) {
if (test_bit(bit, evAbsBits)) {
if (ioctl(fd, EVIOCGABS(bit), &deviceRecordPrivate->axisInfo[bit]) < 0 ||
deviceRecordPrivate->axisInfo[bit].minimum == deviceRecordPrivate->axisInfo[bit].maximum) {
continue;
}
deviceRecordPrivate->axisMap[bit] = deviceRecord->numAxes;
deviceRecord->numAxes++;
}
}
deviceRecord->numButtons = 0;
for (bit = BTN_MISC; bit < KEY_CNT; bit++) {
if (test_bit(bit, evKeyBits)) {
deviceRecordPrivate->buttonMap[bit - BTN_MISC] = deviceRecord->numButtons;
deviceRecord->numButtons++;
}
}
deviceRecord->axisStates = calloc(sizeof(float), deviceRecord->numAxes);
deviceRecord->buttonStates = calloc(sizeof(bool), deviceRecord->numButtons);
if (Gamepad_deviceAttachCallback != NULL) {
Gamepad_deviceAttachCallback(deviceRecord, Gamepad_deviceAttachContext);
}
pthread_create(&deviceRecordPrivate->thread, NULL, deviceThread, deviceRecord);
}
}
closedir(dev_input);
}
lastInputStatTime = currentTime;
pthread_mutex_unlock(&devicesMutex);
}示例8: vk_init
static int vk_init(struct ev *e)
{
char vk_path[PATH_MAX] = "/sys/board_properties/virtualkeys.";
char vks[2048], *ts;
ssize_t len;
int vk_fd;
int i;
e->vk_count = 0;
len = strlen(vk_path);
len = ioctl(e->fd->fd, EVIOCGNAME(sizeof(vk_path) - len), vk_path + len);
if (len <= 0)
return -1;
vk_fd = open(vk_path, O_RDONLY);
if (vk_fd < 0)
return -1;
len = read(vk_fd, vks, sizeof(vks)-1);
close(vk_fd);
if (len <= 0)
return -1;
vks[len] = '\0';
/* Parse a line like:
keytype:keycode:centerx:centery:width:height:keytype2:keycode2:centerx2:...
*/
for (ts = vks, e->vk_count = 1; *ts; ++ts) {
if (*ts == ':')
++e->vk_count;
}
if (e->vk_count % 6) {
LOGW("minui: %s is %d %% 6\n", vk_path, e->vk_count % 6);
}
e->vk_count /= 6;
if (e->vk_count <= 0)
return -1;
e->sent = 0;
e->mt_idx = 0;
ioctl(e->fd->fd, EVIOCGABS(ABS_X), &e->p.xi);
ioctl(e->fd->fd, EVIOCGABS(ABS_Y), &e->p.yi);
e->p.pressed = 0;
ioctl(e->fd->fd, EVIOCGABS(ABS_MT_POSITION_X), &e->mt_p.xi);
ioctl(e->fd->fd, EVIOCGABS(ABS_MT_POSITION_Y), &e->mt_p.yi);
e->mt_p.pressed = 0;
e->vks = malloc(sizeof(*e->vks) * e->vk_count);
for (i = 0; i < e->vk_count; ++i) {
char *token[6];
int j;
for (j = 0; j < 6; ++j) {
token[j] = vk_strtok_r((i||j)?NULL:vks, ":", &ts);
}
if (strcmp(token[0], "0x01") != 0) {
/* Java does string compare, so we do too. */
LOGW("minui: %s: ignoring unknown virtual key type %s\n", vk_path, token[0]);
continue;
}
e->vks[i].scancode = strtol(token[1], NULL, 0);
e->vks[i].centerx = strtol(token[2], NULL, 0);
e->vks[i].centery = strtol(token[3], NULL, 0);
e->vks[i].width = strtol(token[4], NULL, 0);
e->vks[i].height = strtol(token[5], NULL, 0);
}
return 0;
}示例9: IOCTL
#endif
IOCTL(EVIOCGNAME(0)),
IOCTL(EVIOCGPHYS(0)),
IOCTL(EVIOCGUNIQ(0)),
#ifdef EVIOCGPROP
IOCTL(EVIOCGPROP(0)),
#endif
#ifdef EVIOCGMTSLOTS
IOCTL(EVIOCGMTSLOTS(0)),
#endif
IOCTL(EVIOCGKEY(0)),
IOCTL(EVIOCGLED(0)),
IOCTL(EVIOCGSND(0)),
IOCTL(EVIOCGSW(0)),
IOCTL(EVIOCGBIT(0,0)),
IOCTL(EVIOCGABS(0)),
IOCTL(EVIOCSABS(0)),
IOCTL(EVIOCSFF),
IOCTL(EVIOCRMFF),
IOCTL(EVIOCGEFFECTS),
IOCTL(EVIOCGRAB),
#ifdef EVIOCSCLOCKID
IOCTL(EVIOCSCLOCKID),
#endif
};
static const char *const input_devs[] = {
"input",
};
static void input_sanitise(const struct ioctl_group *grp, int childno)示例10: input_sanitise
static void input_sanitise(const struct ioctl_group *grp, int childno)
{
unsigned int u, r;
pick_random_ioctl(grp, childno);
switch (shm->syscall[childno].a2) {
case EVIOCGNAME(0):
u = rand();
shm->syscall[childno].a2 = EVIOCGNAME(u);
break;
case EVIOCGPHYS(0):
u = rand();
shm->syscall[childno].a2 = EVIOCGPHYS(u);
break;
case EVIOCGUNIQ(0):
u = rand();
shm->syscall[childno].a2 = EVIOCGUNIQ(u);
break;
#ifdef EVIOCGPROP
case EVIOCGPROP(0):
u = rand();
shm->syscall[childno].a2 = EVIOCGPROP(u);
break;
#endif
#ifdef EVIOCGMTSLOTS
case EVIOCGMTSLOTS(0):
u = rand();
shm->syscall[childno].a2 = EVIOCGMTSLOTS(u);
break;
#endif
case EVIOCGKEY(0):
u = rand();
shm->syscall[childno].a2 = EVIOCGKEY(u);
break;
case EVIOCGLED(0):
u = rand();
shm->syscall[childno].a2 = EVIOCGLED(u);
break;
case EVIOCGSND(0):
u = rand();
shm->syscall[childno].a2 = EVIOCGSND(u);
break;
case EVIOCGSW(0):
u = rand();
shm->syscall[childno].a2 = EVIOCGSW(u);
break;
case EVIOCGBIT(0,0):
u = rand();
r = rand();
if (u % 10) u %= EV_CNT;
if (r % 10) r /= 4;
shm->syscall[childno].a2 = EVIOCGBIT(u, r);
break;
case EVIOCGABS(0):
u = rand();
if (u % 10) u %= ABS_CNT;
shm->syscall[childno].a2 = EVIOCGABS(u);
break;
case EVIOCSABS(0):
u = rand();
if (u % 10) u %= ABS_CNT;
shm->syscall[childno].a2 = EVIOCSABS(u);
break;
default:
break;
}
}示例11: aipInitEventDev
/* Init Event Device Properties */
static byte aipInitEventDev(AIP_EVP e){
/* Variables */
char vk_path[PATH_MAX] = "/sys/board_properties/virtualkeys.";
char vks[2048], *ts = NULL;
ssize_t len;
int vk_fd;
int i;
e->vkn = 0;
len = strlen(vk_path);
len = ioctl(_aip->fds[e->fd_id].fd, EVIOCGNAME(sizeof(e->device_name)), e->device_name);
if (len <= 0){
return 0;
}
/* Blacklist these "input" devices */
if (strcmp(e->device_name, "bma250") == 0){
e->ignored = 1;
}
/* virtualkeys.{device_name} */
strcat(vk_path, e->device_name);
/* Some devices split the keys from the touchscreen */
e->vkn = 0;
vk_fd = open(vk_path, O_RDONLY);
if (vk_fd >= 0){
/* Read Contents */
len = read(vk_fd, vks, sizeof(vks)-1);
close(vk_fd);
/* Return False on Failed */
if (len<=0){
return 0;
}
/* Add string break */
vks[len] = '\0';
/* Parse a line like:
keytype:keycode:centerx:centery:width:height:keytype2:keycode2:centerx2:...
*/
for (ts=vks, e->vkn=1; *ts; ++ts) {
if (*ts == ':'){
e->vkn++;
}
}
e->vkn /= 6;
if (e->vkn <= 0){
return 0;
}
e->down = 0;
}
/* IOCTL ABS DEVICE */
ioctl(_aip->fds[e->fd_id].fd, EVIOCGABS(AIP_ABS_X), &e->p.xi);
ioctl(_aip->fds[e->fd_id].fd, EVIOCGABS(AIP_ABS_Y), &e->p.yi);
ioctl(_aip->fds[e->fd_id].fd, EVIOCGABS(AIP_ABS_MT_POSITION_X), &e->mt_p.xi);
ioctl(_aip->fds[e->fd_id].fd, EVIOCGABS(AIP_ABS_MT_POSITION_Y), &e->mt_p.yi);
e->p.synced = 0;
e->mt_p.synced = 0;
/* LOGS */
printf("\nDEVICE NAME: %s - %s\n", e->device_name, vk_path);
printf("EV ST: minX: %d maxX: %d minY: %d maxY: %d\n", e->p.xi.minimum, e->p.xi.maximum, e->p.yi.minimum, e->p.yi.maximum);
printf("EV MT: minX: %d maxX: %d minY: %d maxY: %d\n", e->mt_p.xi.minimum, e->mt_p.xi.maximum, e->mt_p.yi.minimum, e->mt_p.yi.maximum);
/* Allocate Virtualkeys Count */
e->vks = malloc(sizeof(AIP_VK) * e->vkn);
for (i=0; i<e->vkn; ++i) {
char * token[6];
int j;
for (j=0; j<6; ++j) {
token[j] = aipStrTokR((i||j)?NULL:vks, ":", &ts);
}
if (strcmp(token[0],"0x01") != 0) {
continue;
}
/* Dump It */
e->vks[i].scan = strtol(token[1], NULL, 0);
e->vks[i].x = strtol(token[2], NULL, 0);
e->vks[i].y = strtol(token[3], NULL, 0);
e->vks[i].w = strtol(token[4], NULL, 0);
e->vks[i].h = strtol(token[5], NULL, 0);
}
/* OK */
return 1;
}示例12: lightgun_event_abs_init
void lightgun_event_abs_init(void)
{
int i;
for (i = 0; i < GUN_MAX; i++) {
char name[256] = "Unknown";
uint8_t abs_bitmask[ABS_MAX/8 + 1];
struct input_absinfo abs_features;
if (!lg_devices[i].device)
continue;
if ((lg_devices[i].fd = open(lg_devices[i].device, O_RDONLY)) < 0) {
fprintf(stderr_file, "Lightgun%d: %s[open]: %s",
i + 1, lg_devices[i].device, strerror(errno));
continue;
}
if (ioctl(lg_devices[i].fd, EVIOCGNAME(sizeof(name)), name) < 0) {
fprintf(stderr_file, "Lightgun%d: %s[ioctl/EVIOCGNAME]: %s\n",
i + 1, lg_devices[i].device, strerror(errno));
lg_devices[i].device = NULL;
continue;
}
memset(abs_bitmask, 0, sizeof(abs_bitmask));
if (ioctl(lg_devices[i].fd, EVIOCGBIT(EV_ABS, sizeof(abs_bitmask)), abs_bitmask) < 0) {
fprintf(stderr_file, "Lightgun%d: %s[ioctl/EVIOCGNAME]: %s\n",
i + 1, lg_devices[i].device, strerror(errno));
lg_devices[i].device = NULL;
continue;
}
/* Make sure we have an X and Y axis. Not much good
* without it. */
if (!test_bit(ABS_X, abs_bitmask) || !test_bit(ABS_Y, abs_bitmask)) {
fprintf(stderr_file, "Lightgun%d: %s: Does not contain both X and Y axis, "
"ignoring\n", i + 1, lg_devices[i].device);
lg_devices[i].device = NULL;
continue;
}
if (ioctl(lg_devices[i].fd, EVIOCGABS(ABS_X), &abs_features)) {
fprintf(stderr_file, "Lightgun%d: %s[ioctl/EVIOCGABS(ABX_X)]: %s\n",
i + 1, lg_devices[i].device, strerror(errno));
lg_devices[i].device = NULL;
continue;
}
lg_devices[i].min[LG_X_AXIS] = abs_features.minimum;
lg_devices[i].range[LG_X_AXIS] = abs_features.maximum - abs_features.minimum;
if (ioctl(lg_devices[i].fd, EVIOCGABS(ABS_Y), &abs_features)) {
fprintf(stderr_file, "Lightgun%d: %s[ioctl/EVIOCGABS(ABX_Y)]: %s\n",
i + 1, lg_devices[i].device, strerror(errno));
lg_devices[i].device = NULL;
continue;
}
lg_devices[i].min[LG_Y_AXIS] = abs_features.minimum;
lg_devices[i].range[LG_Y_AXIS] = abs_features.maximum - abs_features.minimum;
fprintf(stderr_file, "Lightgun%d: %s\n", i + 1, name);
fprintf(stderr_file, " X axis: min[%d] range[%d]\n",
lg_devices[i].min[LG_X_AXIS], lg_devices[i].range[LG_X_AXIS]);
fprintf(stderr_file, " Y axis: min[%d] range[%d]\n",
lg_devices[i].min[LG_Y_AXIS], lg_devices[i].range[LG_Y_AXIS]);
}
}示例13: evdev_handle_device
static int
evdev_handle_device(struct evdev_device *device)
{
struct input_absinfo absinfo;
unsigned long ev_bits[NBITS(EV_MAX)];
unsigned long abs_bits[NBITS(ABS_MAX)];
unsigned long rel_bits[NBITS(REL_MAX)];
unsigned long key_bits[NBITS(KEY_MAX)];
int has_key, has_abs;
unsigned int i;
has_key = 0;
has_abs = 0;
device->caps = 0;
ioctl(device->fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits);
if (TEST_BIT(ev_bits, EV_ABS)) {
has_abs = 1;
ioctl(device->fd, EVIOCGBIT(EV_ABS, sizeof(abs_bits)),
abs_bits);
if (TEST_BIT(abs_bits, ABS_X)) {
ioctl(device->fd, EVIOCGABS(ABS_X), &absinfo);
device->abs.min_x = absinfo.minimum;
device->abs.max_x = absinfo.maximum;
device->caps |= EVDEV_MOTION_ABS;
}
if (TEST_BIT(abs_bits, ABS_Y)) {
ioctl(device->fd, EVIOCGABS(ABS_Y), &absinfo);
device->abs.min_y = absinfo.minimum;
device->abs.max_y = absinfo.maximum;
device->caps |= EVDEV_MOTION_ABS;
}
if (TEST_BIT(abs_bits, ABS_MT_SLOT)) {
ioctl(device->fd, EVIOCGABS(ABS_MT_POSITION_X),
&absinfo);
device->abs.min_x = absinfo.minimum;
device->abs.max_x = absinfo.maximum;
ioctl(device->fd, EVIOCGABS(ABS_MT_POSITION_Y),
&absinfo);
device->abs.min_y = absinfo.minimum;
device->abs.max_y = absinfo.maximum;
device->is_mt = 1;
device->mt.slot = 0;
device->caps |= EVDEV_TOUCH;
}
}
if (TEST_BIT(ev_bits, EV_REL)) {
ioctl(device->fd, EVIOCGBIT(EV_REL, sizeof(rel_bits)),
rel_bits);
if (TEST_BIT(rel_bits, REL_X) || TEST_BIT(rel_bits, REL_Y))
device->caps |= EVDEV_MOTION_REL;
}
if (TEST_BIT(ev_bits, EV_KEY)) {
has_key = 1;
ioctl(device->fd, EVIOCGBIT(EV_KEY, sizeof(key_bits)),
key_bits);
if (TEST_BIT(key_bits, BTN_TOOL_FINGER) &&
!TEST_BIT(key_bits, BTN_TOOL_PEN) &&
has_abs)
device->dispatch = evdev_touchpad_create(device);
for (i = KEY_ESC; i < KEY_MAX; i++) {
if (i >= BTN_MISC && i < KEY_OK)
continue;
if (TEST_BIT(key_bits, i)) {
device->caps |= EVDEV_KEYBOARD;
break;
}
}
for (i = BTN_MISC; i < KEY_OK; i++) {
if (TEST_BIT(key_bits, i)) {
device->caps |= EVDEV_BUTTON;
break;
}
}
}
if (TEST_BIT(ev_bits, EV_LED)) {
device->caps |= EVDEV_KEYBOARD;
}
/* This rule tries to catch accelerometer devices and opt out. We may
* want to adjust the protocol later adding a proper event for dealing
* with accelerometers and implement here accordingly */
if (has_abs && !has_key && !device->is_mt) {
weston_log("input device %s, %s "
"ignored: unsupported device type\n",
device->devname, device->devnode);
return 0;
}
return 1;
}示例14: deviceFd
//.........这里部分代码省略.........
{
relAxisMap[i]=numAxes;
++numAxes;
++numRelAxes;
}
else
relAxisMap[i]=-1;
}
#ifdef VERBOSE
printf("HIDDevice: %d relative axes found\n",numRelAxes);
fflush(stdout);
#endif
}
/* Set number of valuators on device: */
setNumValuators(numAxes,configFile);
/* Initialize axis converters: */
axisConverters=new AxisConverter[numAxes];
if(absAxisMap!=0)
{
/* Initialize absolute axis converters: */
#ifdef VERBOSE
printf("HIDDevice: Initializing absolute axis converters\n");
fflush(stdout);
#endif
for(int i=0;i<=ABS_MAX;++i)
if(absAxisMap[i]>=0)
{
/* Query configuration of this axis: */
input_absinfo absAxisConf;
if(ioctl(deviceFd,EVIOCGABS(i),&absAxisConf)<0)
Misc::throwStdErr("HIDDevice: Unable to query device absolute axis configuration");
#ifdef VERBOSE
printf("Axis %2d: min %d, max %d, fuzz %d, flat %d\n",absAxisMap[i],absAxisConf.minimum,absAxisConf.maximum,absAxisConf.fuzz,absAxisConf.flat);
fflush(stdout);
#endif
/* Initialize converter with queried values: */
AxisConverter& converter=axisConverters[absAxisMap[i]];
float mid=Math::mid(absAxisConf.minimum,absAxisConf.maximum);
converter=AxisConverter(absAxisConf.minimum,mid-absAxisConf.flat,mid+absAxisConf.flat,absAxisConf.maximum);
/* Override axis settings from configuration file: */
char axisSettingsTag[20];
snprintf(axisSettingsTag,sizeof(axisSettingsTag),"axis%dSettings",absAxisMap[i]);
converter=configFile.retrieveValue<AxisConverter>(axisSettingsTag,converter);
#ifdef VERBOSE
printf("Axis %2d: %s\n",absAxisMap[i],Misc::ValueCoder<AxisConverter>::encode(converter).c_str());
fflush(stdout);
#endif
}
}
if(relAxisMap!=0)
{
/* Initialize relative axis converters: */
#ifdef VERBOSE
printf("HIDDevice: Initializing relative axis converters\n");
fflush(stdout);
#endif
for(int i=0;i<=REL_MAX;++i)示例15: init_hid_device
//.........这里部分代码省略.........
}
stick_axis_count = stick_init_param.axis_count;
memcpy(axis_code,stick_init_param.axis_code,AXIS_COUNT*sizeof(int));
}
else {
if(event_mode == STICK_MODE_EVENT) {
for (cnt = MIN_ABS_CODE; cnt < MAX_ABS_CODE; cnt++) {
if (TEST_BIT(cnt, abs_bits)) {
axis_code[stick_axis_count++] = cnt;
dbgprintf(stderr,"Available axis: %d (0x%x)\n",cnt,cnt);
}
if (stick_axis_count == AXIS_COUNT) break;
}
} else {
for (cnt = 0; cnt < axes; cnt++) {
axis_code[stick_axis_count++] = cnt;
dbgprintf(stderr,"Available axis: %d (0x%x)\n",cnt,cnt);
if (stick_axis_count == AXIS_COUNT) break;
}
}
// at least 2 axis are needed in auto detection
if (stick_axis_count < 2) {
dbgprintf(stderr,"ERROR: no suitable axis found [%s:%d]\n",__FILE__,__LINE__);
return(1);
}
}
/* Axis param */
for (cnt = 0; cnt < stick_axis_count; cnt++)
{
if (event_mode == STICK_MODE_EVENT ) {
/* get axis value range */
if (ioctl(stick_device_handle,EVIOCGABS(axis_code[cnt]),valbuf)<0) {
dbgprintf(stderr,"ERROR: can not get axis %d value range (%s) [%s:%d]\n",
cnt,strerror(errno),__FILE__,__LINE__);
return(1);
}
axis_min[cnt]=valbuf[1];
axis_max[cnt]=valbuf[2];
} else {
// with joystick interface, all axes are signed 16 bit with full range
axis_min[cnt]=-32768;
axis_max[cnt]=32768;
}
if (axis_min[cnt]>=axis_max[cnt]) {
dbgprintf(stderr,"ERROR: bad axis %d value range (%d,%d) [%s:%d]\n",
cnt,axis_min[cnt],axis_max[cnt],__FILE__,__LINE__);
return(1);
}
dbgprintf(stderr,"Axis %d : parameters = [%d,%d]\n",
cnt,axis_min[cnt],axis_max[cnt]);
}
//--------------------------------------------------
// force feedback, TBD feature
//--------------------------------------------------
#if 0
/* Now get some information about force feedback */
memset(ff_bits,0,32*sizeof(unsigned long));
if (ioctl(device_handle,EVIOCGBIT(EV_FF ,32*sizeof(unsigned long)),ff_bits)<0) {
dbgprintf(stderr,"ERROR: can not get ff bits (%s) [%s:%d]\n",
strerror(errno),__FILE__,__LINE__);
return(1);
}