linux-input/test/raw.cpp

Go to the documentation of this file.

/*
 * raw.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 * Performs raw lookups and reads of linux input devices (/dev/input/jsX files)
 */

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

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


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

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

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

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

        // get the number of axes
        unsigned char nAxes;
        THROW(ioctl(fd, JSIOCGAXES, &nAxes) >= 0,
            "Failed to determine number of axes");
        DPRINTF("Number of axes: %d", nAxes);

        // get the number of buttons
        unsigned char nButtons;
        THROW(ioctl(fd, JSIOCGBUTTONS, &nButtons) >= 0,
            "Failed to determine number of buttons");
        DPRINTF("Number of buttons: %d", nButtons);

        // 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
        const int nMax = 128;
        THROW(nAxes <= nMax, "Too many axes!");
        THROW(nButtons <= nMax, "Too many buttons!");
        short axes[nMax];
        byte_t buttons[nMax];

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

                // poll events
                int nEvents = 0;
                struct js_event events[32];
                int mask = 0x0f;
                while (true) {
                        int len = read(fd, events, sizeof(events));
                        if (len <= 0)
                                break;          // no more events!

                        nEvents = len / sizeof(events[0]);
                        for (int i = 0; i < nEvents; ++i) {
                                switch (events[i].type & mask) {
                                case JS_EVENT_AXIS:
                                //      DPRINTF("Axis event!");
                                //      DPRINTF("  Axis: %d", events[i].number);
                                //      DPRINTF("  value: %d", events[i].value);
                                        axes[events[i].number] = events[i].value;
                                        break;

                                case JS_EVENT_BUTTON:
                                //      DPRINTF("Button event!");
                                //      DPRINTF("  Button: %d", events[i].number);
                                //      DPRINTF("  value: %d", events[i].value);
                                        if (events[i].value) {
                                                buttons[events[i].number] = 1;
                                        }
                                        break;

                                default:
                                        DPRINTF("Unknown event type: %d",
                                            events[i].type);
                                }
                        }
                }

                // 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("            ");
                printf("\n");
        }
}



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        const char * path = "/dev/input/js0";
        if (argc < 2) {
                DPRINTF("No device path specified, using default: %s", path);
        } else {
                path = argv[1];
        }

        int retval = 0;
        try {
                perf::Timer timer("overall timer");

                doTest(path);

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

        perf::dumpTimingSummary(std::cerr);

        return retval;
}