events.cpp

Go to the documentation of this file.

/*
 * events.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 * Uses the event devices to read/write joysticks (/dev/input/eventX)
 */

// includes --------------------------------------------------------------------
#include <linux/input.h>
#include <iostream>
#include <time.h>

#include "common/common.h"
#include "perf/perf.h"
#include "util/file.h"


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////


#define CASE( XYZ ) if (test_bit( XYZ , eventTypes)) { DPRINTF("%s ", #XYZ ); }


static bool
test_bit
(
IN int bit,
IN const byte_t * array
)
throw()
{
        ASSERT(bit >= 0, "bad bit: %d", bit);
        ASSERT(array, "null");

        int offset = bit / 8;
        const byte_t * p = array + offset;
        int mask = 1 << (bit % 8);
        return !!(*p & mask);
}



static int
getIndex
(
IN int code,
IN const int * array
)
{
        ASSERT(code >= 0, "bad code: %d", code);
        ASSERT(array, "null");

        int i = 0;
        while (true) {
                if (*array == code)
                        return i;
                ++i;
                ++array;
        }
}



static void
doRumble
(
IN smart_fd& fd,
IN int value,
IN int big
)
{
        static int eid = -1;
        if (value) {
                // turn on rumble...
                if (-1 != eid)
                        return; // already rumbling!

                // upload and turn on rumble!
                ff_effect e;
                e.type = FF_RUMBLE;
                e.id = -1;
                uint16_t strength = 0xe000;
                e.u.rumble.strong_magnitude = (big) ? strength : 0;
                e.u.rumble.weak_magnitude = (!big) ? strength : 0;
                e.replay.length = 2000;
                e.replay.delay = 0;

                if (ioctl(fd, EVIOCSFF, &e) < 0) {
                        DPRINTF("Failed to upload rumble");
                        return;
                }
                eid = e.id;

                input_event play;
                play.type = EV_FF;
                play.code = eid;
                play.value = 1;
                if (write(fd, (const void *) &play, sizeof(play)) <= 0) {
                        DPRINTF("Failed to play rumble");
                        return;
                }
        } else {
                // disable rumbling...
                if (-1 == eid)
                        return;         // not rumbling right now

                // turn off and delete rumble
                input_event stop;
                stop.type = EV_FF;
                stop.code = eid;
                stop.value = 0;
                if (write(fd, (const void *) &stop, sizeof(stop)) <= 0) {
                        DPRINTF("Failed to stop rumble");
                        return;
                }

                if (ioctl(fd, EVIOCRMFF, eid) < 0) {
                        DPRINTF("Failed to remove rumble");
                        return;
                }
                eid = -1;
        }
}

 

static void
doTest
(
IN const char * path
)
{
        THROW(path, "null device path");

        DPRINTF("path: %s", path);
        smart_fd fd;
        THROW(fd.open(path, O_RDWR), "Failed to open device path: " << path);

        // get the name of the device
        const int bufsize = 1024;
        char devname[bufsize];
        THROW(ioctl(fd, EVIOCGNAME(bufsize), devname) >= 0,
            "Failed to acquire device name");
        DPRINTF("Device name: '%s'", devname);

        char uniq[bufsize];
        if (ioctl(fd, EVIOCGUNIQ(bufsize), uniq) < 0) {
                DPRINTF("Failed to acquire unique device ID");
        } else {
                DPRINTF("Unique ID: '%s'", uniq);
        }

        // get the device info
        struct input_id iid;
        THROW(ioctl(fd, EVIOCGID, &iid) >= 0,
            "Failed to acquire device id");
        DPRINTF("Bus type: %08x = %d", iid.bustype, iid.bustype);
        DPRINTF("Vendor:   %08x = %d", iid.vendor, iid.vendor);
        DPRINTF("Product:  %08x = %d", iid.product, iid.product);
        DPRINTF("Version:  %08x = %d", iid.version, iid.version);

        // query force-feedback capabilities
        byte_t features[(FF_MAX + 7) / 8];
        THROW(ioctl(fd, EVIOCGBIT(EV_FF, sizeof(features)), features) >= 0,
            "Failed to query for force-feedback capabilities");

        printf("\nList of force feedback effects: ");
        if (test_bit(FF_RUMBLE, features))   printf("Rumble ");
        if (test_bit(FF_PERIODIC, features)) printf("Periodic ");
        if (test_bit(FF_CONSTANT, features)) printf("Constant ");
        if (test_bit(FF_SPRING, features))   printf("Spring ");
        if (test_bit(FF_FRICTION, features)) printf("Friction ");
//      if (test_bit(FF_DAMPER, features))   printf("Damper ");
//      if (test_bit(FF_INERTIA, features))  printf("Inertia ");
//      if (test_bit(FF_RAMP, features))     printf("Ramp ");
        printf("\n");

        int n_effects; /* Number of effects the device can play at the same time */
        THROW(ioctl(fd, EVIOCGEFFECTS, &n_effects) >= 0,
            "Failed to query number of simultaneous force-feedback effects");
        DPRINTF("Can play %d simultaneous force-feedback effects", n_effects);

        // determine capabilities
        byte_t eventTypes[(EV_MAX + 7) / 8];
        THROW(ioctl(fd, EVIOCGBIT(0, sizeof(eventTypes)), eventTypes) >= 0,
            "Failed to retrieve event types");

        // list events
        printf("Events: ");
        CASE(EV_SYN)
        CASE(EV_KEY)
        CASE(EV_REL)
        CASE(EV_ABS)
        CASE(EV_MSC)
        CASE(EV_SW)
        CASE(EV_LED)
        CASE(EV_SND)
        CASE(EV_REP)
        CASE(EV_FF)
        CASE(EV_PWR)
        CASE(EV_FF_STATUS)

        // first, look up buttons
        const int nMax = 128;
        THROW(test_bit(EV_KEY, eventTypes),
            "Device reports no buttons/keys?");
        int nButtons = 0;
        byte_t keyStats[(KEY_MAX + 7) / 8];
        THROW(ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keyStats)), keyStats) >= 0,
            "Failed to retrieve button types");
        printf("Buttons:");
        int btnIndex[nMax];
        for (int i = 0; i < KEY_MAX; ++i) {
                if (test_bit(i, keyStats)) {
                        printf(" %d", i);
                        btnIndex[nButtons] = i;
                        nButtons++;
                }
        }
        printf("\n");
        DPRINTF("Found %d buttons total", nButtons);

        // look up absolute axes
        THROW(test_bit(EV_ABS, eventTypes),
            "Device reports no absolute axes?");
        int nAxes = 0;
        byte_t axisStats[(ABS_MAX + 7) / 8];
        THROW(ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(axisStats)), axisStats) >= 0,
            "Failed to retrieve absolute axis types");
        printf("Axes:");
        int axisIndex[nMax];
        for (int i = 0; i < ABS_MAX; ++i) {
                if (test_bit(i, axisStats)) {
                        printf(" %d", i);
                        axisIndex[nAxes] = i;
                        nAxes++;
                }
        }
        printf("\n");
        DPRINTF("Found %d axes total", nAxes);

        // set to non-blocking now
        THROW(!fcntl(fd, F_SETFL, O_NONBLOCK),
            "Failed to set device path as nonblocking");

        // keep polling
        const int desiredHz = 100;
        int msSleep = 1000 / desiredHz;
        DPRINTF("Want to run at %d Hz", desiredHz);
        DPRINTF("  That means polling every %d milliseconds", msSleep);
        long nsSleep = 1000 * 1000 * msSleep;
        DPRINTF("  Which is %ld nanoseconds", nsSleep);
        struct timespec ts;
        ts.tv_sec = 0;
        ts.tv_nsec = nsSleep;

        // keep state here
        THROW(nAxes <= nMax, "Too many axes!");
        THROW(nButtons <= nMax, "Too many buttons!");
        short axes[nMax];
        byte_t buttons[nMax];
        memset(axes, 0, sizeof(axes));
        memset(buttons, 0, sizeof(buttons));

        // loop
        printf("\n");
        for (;;) {
                nanosleep(&ts, NULL);

                // poll events
                int nEvents = 0;
                struct input_event events[32];
                while (true) {
                        int len = read(fd, events, sizeof(events));
                        if (len <= 0)
                                break;          // end of events

                        // parse events
                        nEvents = len / sizeof(input_event);
                        for (int i = 0; i < nEvents; ++i) {
                                int idx;
                                switch(events[i].type) {
                                case EV_KEY:
                                        idx = getIndex(events[i].code, btnIndex);
                                //      DPRINTF("%d --> index %d", events[i].code, idx);
                                //      DPRINTF("button %d: %d", idx, events[i].value);
                                        buttons[idx] = events[i].value;
                                        if (idx < 2) {
                                                // button zero or one!  toggle rumble
                                                doRumble(fd, events[i].value, idx);
                                        }
                                        break;

                                case EV_ABS:
                                        idx = getIndex(events[i].code, axisIndex);
                                        axes[idx] = events[i].value;
                                        break;
                                }
                        }
                }

                // write out state
                printf("\r");
                printf("%02d", nEvents);
                for (int i = 0; i < nAxes; ++i) {
                        printf(" %6d", axes[i]);
                }
                printf(":");
                for (int i = 0; i < nButtons; ++i) {
                        if (buttons[i]) {
                                printf(" b%02d", i);
                //              buttons[i] = 0;
                        }
                }
                printf("            ");
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;
        try {
                perf::Timer timer("overall timer");

                THROW(2 == argc, "Usage: linux-joy-events <event-device-path>"
                    << "\nAn example path is /dev/input/event8");
                const char * path = argv[1];

                doTest(path);

        } catch (std::exception& e) {
                DPRINTF("EXCEPTION: %s", e.what());
                retval = 1;
        }

        perf::dumpTimingSummary(std::cerr);

        return retval;
}