linux-input/test/test.cpp

Go to the documentation of this file.

/*
 * test.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 * Simple test for linux-input source devices.
 */

// includes --------------------------------------------------------------------
#include <time.h>

#include <iostream>

#include "linux-input/linux-input.h"
#include "perf/perf.h"


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

static int
getIntDigits
(
IN int x
)
throw()
{
        if (x <= 9)
                return 1;

        int nDigits = 1;
        while (x > 10) {
                x /= 10;
                nDigits++;
        }

        return nDigits;
}



static int
getPotDigits
(
IN int min,
IN int max
)
throw()
{
        int minDigits = 0;
        if (min < 0) {
                minDigits = getIntDigits(-min) + 1;
        }
        int maxDigits = getIntDigits(max);

        if (minDigits > maxDigits) {
                return minDigits;
        }
        return maxDigits;
}


static void
printPot
(
IN int idx,
IN const gamepad::pot_value_t& pv
)
throw()
{
        int valDigits = getPotDigits(pv.minSeen, pv.maxSeen);

//      DPRINTF("Pot min=%d, max=%d", pv.minSeen, pv.maxSeen);

        const int bufsize = 64;
        char format[bufsize];

//      snprintf(format, bufsize, "%%d:%%%dd ", valDigits);
        snprintf(format, bufsize, "%%%dd ", valDigits);
//      DPRINTF("  format string: '%s'", format);

//      printf(format, idx, pv.value);
        printf(format, pv.value);
/*      if (phase & 1) {
                // show min
                if (gamepad::pot_value_t::eStartMin == pv.minSeen) {
                        printf("X");
                } else {
                        printf("%d", pv.minSeen);
                }
        } else {
                // show max
                if (gamepad::pot_value_t::eStartMax == pv.maxSeen) {
                        printf("X");
                } else {
                        printf("%d", pv.maxSeen);
                }
        }
        printf(" "); */
}



static void
doTest
(
void
)
{
        // create factory object
        bool wantForceFeedbackEvenThoughExtremelyDangerous = true;
        smart_ptr<gamepad::SourceDeviceFactory> factory =
            gamepad::getLinuxInputSourceDeviceFactory(
                wantForceFeedbackEvenThoughExtremelyDangerous);
        ASSERT_THROW(factory,
            "failed to create linux input source device factory");

        // see if there are any linux joystic devices
        int nDevices = factory->getCount();
        DPRINTF("Found %d linux joystick source devices", nDevices);
        ASSERT_THROW(nDevices > 0, "Bad or no joystick devices found?");

#if 1
        // loop through all devices and get info!
        for (int i = 0; i < nDevices; ++i) {
                smart_ptr<gamepad::SourceDevice> device =
                    factory->getSourceDevice(i);
                ASSERT_THROW(device, "Should have a device here");

                // dump the names
                DPRINTF("Device %d: '%s'", i, device->getPublicName());
                DPRINTF("  unique ID: '%s'", device->getUniqueId());

                DPRINTF("  state: %d", device->getState());
                DPRINTF("  total potentiometers: %d", device->getNumPots());
                DPRINTF("  total buttons: %d", device->getNumButtons());
        }
#endif

        // okay, get the first device
        smart_ptr<gamepad::SourceDevice> device = factory->getSourceDevice(0);
        ASSERT_THROW(device, "should have a device");

        // set up sleep interval
        const int desiredHz = 100;
        long msPoll = 1000 / desiredHz;
        DPRINTF("Want sampling at %d Hz, so polling every %ld ms",
            desiredHz, msPoll);
        ASSERT_THROW(desiredHz > 1, "Need a higher sampling frequency!");
        struct timespec ts;
        ts.tv_sec = 0;
        ts.tv_nsec = msPoll * 1000 * 1000;      // 1ms = 10e6 ns

        // how often do we see if the device is still connected?
        const int connectedHz = 5;
        int checkCounter = desiredHz / connectedHz;
        DPRINTF("Checking connection status every %d iterations",
            checkCounter);
        int counter = 0;

/*
        // Jan 2011: removing all force feedback support for now
        // default rumble values
        uint16_t loFreq = 0x5000;
        uint16_t hiFreq = 0x5000;
        int nRumble = device->getNumRumblers();
        DPRINTF("Found %d rumblers", nRumble);
        if (device->getNumButtons() < nRumble) {
                nRumble = device->getNumButtons();
        }
 */

        int nCols = 100;                // assume 100 columns for display
        int nCharsPerPot = (nCols / device->getNumPots()) - 1;
        if (nCharsPerPot > 6) {
                nCharsPerPot = 6;
        }
        if (nCharsPerPot < 2) {
                nCharsPerPot = 2;
        }
//      char potFormat[64];
//      sprintf(potFormat, "%%d:%%d:%%d ");
//      DPRINTF("Potentiometer format: '%s'", potFormat);

        // now loop and read
        DPRINTF("\n\nDetach the device to stop the program!\n");
        while (gamepad::eDevice_Detached != device->getState()) {
                nanosleep(&ts, NULL);

                counter++;
                if (counter >= checkCounter) {
                        counter = 0;
                        factory->getCount();
                }

                device->poll();
                printf("\r");
                for (int i = 0; i < device->getNumPots(); ++i) {
                        const gamepad::pot_value_t& pv = device->getPotValue(i);
                        printPot(i, pv);
//                      printf(potFormat, pv.minSeen, pv.value, pv.maxSeen);
                }

                printf(" pressed:");
                bool needLinefeed = false;
                for (int i = 0; i < device->getNumButtons(); ++i) {
                        if (gamepad::eButtonWasPushed & device->getButtonValue(i)) {
                                printf(" b%d", i);
                                needLinefeed = true;
                        }
                }
                if (needLinefeed) {
                        printf("\n");
                }

/*
                for (int i = 0; i < nRumble; ++i) {
                        int duration = -1;
                        if (gamepad::eButtonWasPushed & device->getButtonValue(i))
                                duration = 2000;
                        if (gamepad::eButtonWasReleased & device->getButtonValue(i))
                                duration = 0;
                        if (duration < 0)
                                continue;       // skip button

                        uint16_t hi = (i % 2) ? hiFreq : 0;
                        uint16_t lo = (hi) ? 0 : loFreq;
                        device->playRumble(i, hi, lo, duration);
                }
 */
        }
        printf("\n");
        DPRINTF("Device appears to be detached--exiting!");
}



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

int
main
(
IN int argc,
IN const char * argv[]
)
{
        int retval = 0;

        try {
                perf::Timer timer("overall timer");

                doTest();

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

        perf::dumpTimingSummary(std::cerr);

        return retval;
}