C:/Active/libraries/cxutils/2.0/src/cxutils/joystick.cpp

Go to the documentation of this file.

#include "cxutils/joystick.h"
#include <assert.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <iomanip>

#if defined (WIN32)
#include <windows.h>
#include <mmsystem.h>
#else
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <linux/joystick.h>
#include <stdio.h>
#include <sys/ioctl.h>
#endif

#include <map>

const short int JOYSTICK_X_AXIS   =  0;         
const short int JOYSTICK_Y_AXIS   =  1;         
const short int JOYSTICK_Z_AXIS   =  2;         
const short int JOYSTICK_R_AXIS   =  3;         
const short int JOYSTICK_U_AXIS   =  4;         
const short int JOYSTICK_V_AXIS   =  5;         
const short int JOYSTICK_POV_AXIS =  6;         
const short int JOYSTICK_POV_X_AXIS = 7;        
const short int JOYSTICK_POV_Y_AXIS = 8;        
   
    
using namespace std;

namespace CxUtils
{
    class JoystickInterface
    {
    public:
        JoystickInterface()
        {
    #ifdef WIN32
    #else
            mJoyFD = 0;
            mJSCalibratorFlag = false;
    #endif
        }
        ~JoystickInterface()
        {
    #ifdef WIN32
    #else
            mJoyFD = 0;
    #endif
        }
    #ifdef WIN32
        JOYINFOEX mJoyInfoEx;               
    #else
        int mJoyFD;                         
        struct js_event mJoystickEvent;     
        bool mJSCalibratorFlag;             
        std::map<int, int> mAxisMinimum;    
        std::map<int, int> mAxisMaximum;    
        std::map<int, int> mAxisCenter;     
    #endif
    };
}

using namespace CxUtils;


Joystick::Joystick()
{
    mpAxis = new int[9];
    assert(mpAxis);
    memset(mpAxis, 0, sizeof(int)*9);
    mButtons = 0;
    mID = 0;
    mUpdateFrequency = 25;
    mpJoyInterface = new JoystickInterface();
    mJoystickConnected = false;
}


Joystick::~Joystick()
{
    Shutdown();
    if(mpAxis) 
    {
        delete[] mpAxis;
        mpAxis = NULL;
    }
    if(mpJoyInterface)
    {
        delete ((JoystickInterface *)(mpJoyInterface));
    }
}


int Joystick::Initialize(const unsigned int num, 
                         const unsigned int freq,
                         const std::string& calibrationFile)
{
    // Close any previously open connection.
    Shutdown();
    // Get a pointer to our interface wrapper class.
    JoystickInterface* joyInfo = (JoystickInterface*)(mpJoyInterface);
    
    // Try connect to any joystick available.
    if(num == AnyJoystick)
    {
        for(unsigned int i = 0; i <= 10; i++)
        {
            if(Initialize(i, freq, calibrationFile))
            {
                return 1;
            }
        }
        return 0;
    }
    
    // Check for invalid frequency.
    if(freq == 0 || freq > 50)
    {
        return 0;
    }
    
#ifdef WIN32

    joyInfo->mJoyInfoEx.dwSize = sizeof(JOYINFOEX);
    joyInfo->mJoyInfoEx.dwFlags = JOY_RETURNALL;

    if(joyGetPosEx(num, &joyInfo->mJoyInfoEx) != JOYERR_NOERROR)
    {
        return 0;
    }
    mID = num;
    
#else
    char port[256];

    sprintf(port, "/dev/js%d", num);
    joyInfo->mJoyFD = open(port, O_RDONLY);
    if(joyInfo->mJoyFD > 0) 
    {
        mID = num;
    }
    else
    {
        sprintf(port, "/dev/input/js%d", num);
        joyInfo->mJoyFD = open(port, O_RDONLY);
        if(joyInfo->mJoyFD > 0) 
        {
            mID = num;
        }
    }
    
    // Check for failure to open port.
    if(joyInfo->mJoyFD <= 0)
    {
        return 0;
    }
    
    if(joyInfo->mJoyFD > 0 && calibrationFile.empty() == false)
    {
        char name[128];
        if (ioctl(joyInfo->mJoyFD, JSIOCGNAME(sizeof(name)), name) < 0)
            strncpy(name, "Unknown", sizeof(name));
        //cout << "Joystick: " << name << endl;
        FILE *instream = fopen(calibrationFile.c_str(),"r");
        if(instream)
        {
            char numButtons = 0;
            //request number of buttons
            ioctl(joyInfo->mJoyFD, JSIOCGBUTTONS, &numButtons);

            //request number of axes
            int numAxes = 0;
            ioctl(joyInfo->mJoyFD, JSIOCGAXES, &numAxes);;
        
            //cout << "Has configuration File" << endl;
            joyInfo->mJSCalibratorFlag = true;

            char tmpline[1024];            
            int axis=-1;
            while(fgets(tmpline,1024,instream)!=NULL)
            {
                //cout << tmpline << endl;
                if(strstr(tmpline,"BeginAxis"))
                {
                    axis++;
                }
                if(axis >= 0 && axis < numAxes)
                {
                    if(strstr(tmpline,"        Minimum"))
                    {
                        joyInfo->mAxisMinimum[axis] = atoi(strstr(tmpline,"=") + 2);
                        //cout << "Axis " << axis << " Minimum: " << joyInfo->mAxisMinimum[axis] << endl;
                    }
                    else if(strstr(tmpline,"        Center"))
                    {
                        joyInfo->mAxisCenter[axis] = atoi(strstr(tmpline,"=") + 2);
                        //cout << "Axis " << axis << " Center: " << joyInfo->mAxisCenter[axis] << endl;
                    }
                    else if(strstr(tmpline,"        Maximum"))
                    {
                        joyInfo->mAxisMaximum[axis] = atoi(strstr(tmpline,"=") + 2);
                        //cout << "Axis " << axis << " Maximum: " << joyInfo->mAxisMaximum[axis] << endl;
                    }
                }
            }
            fclose(instream);
        }
        else
        {
            joyInfo->mJSCalibratorFlag = false;
            joyInfo->mAxisMinimum.clear();
            joyInfo->mAxisMaximum.clear();
            joyInfo->mAxisCenter.clear();
        }
    }
    
    if(mCallbackThread.CreateThread(&Joystick::CallbackThreadFunction, this) == 0)
    {
        Shutdown();
        return 0;
    }
    
#endif

    // Create thread to poll for joystick data.
    if(mJoystickThread.CreateThread(&Joystick::JoystickThreadFunction, this) == 1)
    {
        mJoystickConnected = true;
        return 1;
    }

    // If we got here, close any open connections.
    Shutdown();
    
    return 0;
}


int Joystick::Shutdown()
{
    // Get a pointer to our interface wrapper class.
    JoystickInterface* joyInfo = (JoystickInterface*)(mpJoyInterface);
    
#ifndef WIN32
    if(joyInfo->mJoyFD != 0)
    {
        close(joyInfo->mJoyFD);
    }
    mCallbackThread.StopThread();
#endif
    mJoystickThread.StopThread();
    
    mUpdateFrequency = 15;
    memset(mpAxis, 0, sizeof(int)*7);
    mButtons = 0;
    mID = 0;
#ifdef WIN32
#else
    joyInfo->mJoyFD = 0;
#endif
    mJoystickConnected = false;
    return 1;
}


int Joystick::GetAxis(const short int axis) const
{
    if(!IsConnected())
        return 0;

    int result = 0;
    if(axis >= 0 && axis < 9) 
    {
        mJoystickMutex.Lock();
        result = mpAxis[axis];
        mJoystickMutex.Unlock();
    }

    return result;
}


int Joystick::GetPOV() const
{
    int result = 0;

    mJoystickMutex.Lock();

#ifdef WIN32
    result = mpAxis[JOYSTICK_POV_AXIS];
    if(result != PovOff)
        result /= 100;
#else
    result = mpAxis[JOYSTICK_POV_AXIS];
#endif
    mJoystickMutex.Unlock();
    return result;
}

int Joystick::GetButtonNumber() const
{
    int result = 0, buttons = 0;
    
    // copy buttons vector
    mJoystickMutex.Lock();
    buttons = mButtons;
    mJoystickMutex.Unlock();

    int bnumber = 1;
    for(int i = 0; i < 32; i++) 
    {
        if( (buttons&bnumber) > 0) 
        {
            result = i + 1;
            break;
        }

        bnumber <<= 1;
    }

    return result;
}


int Joystick::RegisterCallback(JoystickCallback* cb)
{
    if(!cb)
        return 0;

    mJoyCallbackMutex.Lock();

    Callback::Data cbData;
    
    cbData.mpJoyCallback  = cb;
    cbData.mpJoyFunc = NULL;
    cbData.mpJoyFuncArgs = NULL;
    
    mCallbacks.push_back(cbData);
    
    mJoyCallbackMutex.Unlock();

    return 1;
}


int Joystick::RegisterCallback(void (*func)(const Joystick& jstick, void* args), void* args)
{
    if(!func)
        return 0;

    mJoyCallbackMutex.Lock();
    
    Callback::Data cbData;
    
    cbData.mpJoyCallback  = NULL;
    cbData.mpJoyFunc = func;
    cbData.mpJoyFuncArgs = args;
    
    mCallbacks.push_back(cbData);

    mJoyCallbackMutex.Unlock();

    return 1;
}


int Joystick::RegisterCallback(void (*func)(const unsigned int buttonNumber, const Joystick::Event type, void* args), 
                               void* args)
{
    if(!func)
        return 0;

    mJoyCallbackMutex.Lock();
    
    Callback::Data cbData;
    
    cbData.mpJoyCallback  = NULL;
    cbData.mpJoyButtonFunc = func;
    cbData.mpJoyFuncArgs = args;
    
    mCallbacks.push_back(cbData);

    mJoyCallbackMutex.Unlock();

    return 1;
}


void Joystick::ClearCallbacks()
{
    mJoyCallbackMutex.Lock();
    mCallbacks.clear();
    mJoyCallbackMutex.Unlock();
}

void Joystick::PrintJoystickInfo() const
{
    cout << "ID: " << mID << " - ";
    for(int i = 0; i < 6; i++) 
    {
        cout << Joystick::GetLetterFromAxis(i) << ":" << setw(4) << (int)GetAxisPercentage(i) << " ";
    }
    cout << "POV-X: " << GetAxisPercentage(PovX) << " ";
    cout << "POV-Y: " << GetAxisPercentage(PovY) << " ";
    cout << "B: " << GetButtonNumber() << endl;
}


bool Joystick::IsButtonPressed(const unsigned int num) const
{
    bool result = false;
    
    mJoystickMutex.Lock();
    
    if(num == 0 && mButtons != 0)
    {
        result = true;
    }
    else 
    {
        int x = 1;
        x <<= (num - 1);
        if( (x&mButtons) != 0 )
        {
            result = true;
        }
    }
    mJoystickMutex.Unlock();
    
    return result;
}


bool Joystick::IsConnected() const
{
    return mJoystickConnected;
}


double Joystick::GetAxisPercentage(const short int axis, const short int deadzone) const
{
    int val = GetAxis(axis);
    double dead = ( abs(deadzone)*MaxAxisValue )/100.0;
    double perc = 0.0;
    if(dead > MaxAxisValue)
        dead = MaxAxisValue;

    if(axis == POV || axis == PovX || axis == PovY)
    {
        return (double)val;
    }

    perc = (abs(val) <= dead) ? 0.0 : ((abs(val) - dead)*100.0)/(MaxAxisValue - dead);

    if(val < 0)
        perc *= -1.0;

    if(perc > 100.0)
        perc = 100.0;
    else if(perc < -100.0)
        perc = -100.0;

    return perc;
}


void Joystick::JoystickThreadFunction(void *args)
{
    Joystick* joystick = (Joystick*)(args);
    // Get a pointer to our interface wrapper class.
    JoystickInterface* joyInfo = (JoystickInterface*)(joystick->mpJoyInterface);
    
    std::vector<int> buttonsDown;
    std::vector<int> buttonsUp;
    
    while(joystick &&
          joystick->mJoystickThread.QuitThreadFlag() == false)
    {
        buttonsDown.clear();
        buttonsUp.clear();

#if defined(WIN32)

        unsigned int delay;
        delay = (unsigned int)(1000.0/(joystick->mUpdateFrequency + .000000000000000001));
        if(delay < 1)
        {
            delay = 1;         
        }
        SleepMs(delay);
        
        int prevButtons;
        joystick->mJoystickMutex.Lock();
        
        prevButtons = joystick->mButtons;

        //  First get updated information
        joyGetPosEx(joystick->mID, &joyInfo->mJoyInfoEx);
        //  Now copy the updated information
        //  Get the button value.  In windows
        //  the button value is returned as
        //  a power of two
        joystick->mButtons = joyInfo->mJoyInfoEx.dwButtons;
        //  Copy Axis Information and Subtract
        //  32767 so that the middle is 0
        joystick->mpAxis[JOYSTICK_X_AXIS] = joyInfo->mJoyInfoEx.dwXpos - 32767;
        joystick->mpAxis[JOYSTICK_Y_AXIS] = joyInfo->mJoyInfoEx.dwYpos - 32767;
        joystick->mpAxis[JOYSTICK_Z_AXIS] = joyInfo->mJoyInfoEx.dwRpos - 32767;
        joystick->mpAxis[JOYSTICK_R_AXIS] = joyInfo->mJoyInfoEx.dwZpos - 32767;
        joystick->mpAxis[JOYSTICK_U_AXIS] = joyInfo->mJoyInfoEx.dwUpos - 32767;
        joystick->mpAxis[JOYSTICK_V_AXIS] = joyInfo->mJoyInfoEx.dwVpos - 32767;        
        joystick->mpAxis[JOYSTICK_POV_AXIS] = joyInfo->mJoyInfoEx.dwPOV;
        if(joyInfo->mJoyInfoEx.dwPOV == PovOff)
        {
            joystick->mpAxis[PovX] = 0;
            joystick->mpAxis[PovY] = 0;
        }
        if(joyInfo->mJoyInfoEx.dwPOV == 0)
        {
            joystick->mpAxis[PovY] = 100;
        }
        if(joyInfo->mJoyInfoEx.dwPOV == 18000)
        {
            joystick->mpAxis[PovY] = -100;
        }
        if(joyInfo->mJoyInfoEx.dwPOV == 9000)
        {
            joystick->mpAxis[PovX] = 100;
        }
        if(joyInfo->mJoyInfoEx.dwPOV == 27000)
        {
            joystick->mpAxis[PovX] = -100;
        }
        if(joyInfo->mJoyInfoEx.dwPOV == 4500)
        {
            joystick->mpAxis[PovX] = 100;
            joystick->mpAxis[PovY] = 100;
        }
        if(joyInfo->mJoyInfoEx.dwPOV == 13500)
        {
            joystick->mpAxis[PovX] = 100;
            joystick->mpAxis[PovY] = -100;
        }
        if(joyInfo->mJoyInfoEx.dwPOV == 22500)
        {
            joystick->mpAxis[PovX] = -100;
            joystick->mpAxis[PovY] = -100;
        }
        if(joyInfo->mJoyInfoEx.dwPOV == 31500)
        {
            joystick->mpAxis[PovX] = -100;
            joystick->mpAxis[PovY] = 100;
        }

        // Now check for button events.
        for(unsigned int i = 0; i < MaxButtons; i++)
        {
            int mask = 1 << i;
            // Check for down
            if( (prevButtons&mask) == 0 && (joystick->mButtons&mask) > 0)
            {
                buttonsDown.push_back(i + 1);
            }
            // Check for up
            if( (prevButtons&mask) > 0 && (joystick->mButtons&mask) == 0)
            {
                buttonsUp.push_back(i + 1);
            }
        }

        joystick->mJoystickMutex.Unlock();

#else
            
        //  Read for any events
        if(read (joyInfo->mJoyFD, &joyInfo->mJoystickEvent, sizeof(struct js_event)) != -1)
        {
            //printf("Event!\n");
            //  Check the type of event
            if(joyInfo->mJoystickEvent.type == JS_EVENT_BUTTON)
            {
                joystick->mJoystickMutex.Lock();
                //  First see what the button
                //  change too
                if(joyInfo->mJoystickEvent.value == 0)  //  Button released
                {
                    // Get the number of the button release, and clear the
                    // bit for the button in the button vector.
                    joystick->mButtons &= ~(1 << joyInfo->mJoystickEvent.number);
                    buttonsUp.push_back(joyInfo->mJoystickEvent.number + 1);
                }
                else  //  Button pressed
                {
                    //  Get the number pressed and OR with button vector
                    joystick->mButtons |= 1 << joyInfo->mJoystickEvent.number;
                    buttonsDown.push_back(joyInfo->mJoystickEvent.number + 1);
                }
                //printf("Pressed Button %d\n", joystick->mButtons);
                joystick->mJoystickMutex.Unlock();
            }
            else if(joyInfo->mJoystickEvent.type == JS_EVENT_AXIS)
            {
                short int value;
                int axis = 0;
                value = joyInfo->mJoystickEvent.value;
                axis = joyInfo->mJoystickEvent.number;
                joystick->mJoystickMutex.Lock();
                //  First find out which axis
                switch(axis)
                {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                        if(joyInfo->mJSCalibratorFlag)
                        {
                            if(value < joyInfo->mAxisCenter[axis])
                            {
                                joystick->mpAxis[axis]=(short int)((MaxAxisValue*(double)(value - joyInfo->mAxisCenter[axis])/(double)(joyInfo->mAxisCenter[axis]-joyInfo->mAxisMinimum[axis])));
                            }
                            else
                            {                                   
                               joystick->mpAxis[axis]=(short int)((MaxAxisValue*(double)(value - joyInfo->mAxisCenter[axis])/(double)(joyInfo->mAxisMaximum[axis]-joyInfo->mAxisCenter[axis])));
                            }
                        }
                        else
                        {
                            joystick->mpAxis[axis] = value;
                        }
                        if(axis == 3)
                        {
                            if(value == 255)
                            {
                                joystick->mpAxis[axis] = 0;
                            }
                            joystick->mpAxis[axis] *= -1;   
                            joystick->mpAxis[axis] = (int)((joystick->mpAxis[axis] - MaxAxisValue/2.0)*MaxAxisValue/ (MaxAxisValue/2.0));
                        }
                        break;
                    case 4:
                        joystick->mpAxis[JOYSTICK_POV_X_AXIS] = value;
                        break;
                    case 5:
                        joystick->mpAxis[JOYSTICK_POV_Y_AXIS] = value;
                        break;
                    case 6:
                        joystick->mpAxis[JOYSTICK_U_AXIS] = value;
                        break;
                    case 7:
                        joystick->mpAxis[JOYSTICK_V_AXIS] = value;
                    default:
                        break;
                }

                double angle = atan2(-(double)joystick->mpAxis[JOYSTICK_POV_Y_AXIS] , (double)joystick->mpAxis[JOYSTICK_POV_X_AXIS]);
                angle = CX_RAD2DEG(angle);
                if(joystick->mpAxis[JOYSTICK_POV_X_AXIS] == 0 &&
                   joystick->mpAxis[JOYSTICK_POV_Y_AXIS] == 0)
                {
                   angle = PovOff;
                }
                joystick->mpAxis[JOYSTICK_POV_AXIS] = angle;

                joystick->mJoystickMutex.Unlock();
            }
        }

#endif

#ifdef WIN32
        // The callbacks are used in in this thread in Windows only
        // because reading from the joystick is non-blocking in Windows.
        joystick->mJoyCallbackMutex.Lock();
        Callback::Data::List::iterator cb;
        for(cb = joystick->mCallbacks.begin();
            cb != joystick->mCallbacks.end();
            cb++)
        {
            if(cb->mpJoyCallback)
            {
                cb->mpJoyCallback->ProcessJoystickEvent(*joystick);
                for(unsigned int i = 0; i < (unsigned int)buttonsDown.size(); i++)
                {
                    cb->mpJoyCallback->ProcessButtonEvent(buttonsDown[i], Joystick::ButtonDown);
                }
                for(unsigned int i = 0; i < (unsigned int)buttonsUp.size(); i++)
                {
                    cb->mpJoyCallback->ProcessButtonEvent(buttonsUp[i], Joystick::ButtonUp);
                }
            }
            else if(cb->mpJoyFunc)
            {
                cb->mpJoyFunc(*joystick, cb->mpJoyFuncArgs);
            }
            else if(cb->mpJoyButtonFunc)
            {
                for(unsigned int i = 0; i < (unsigned int)buttonsDown.size(); i++)
                {
                    cb->mpJoyButtonFunc(buttonsDown[i], Joystick::ButtonDown, cb->mpJoyFuncArgs);
                }
                for(unsigned int i = 0; i < (unsigned int)buttonsUp.size(); i++)
                {
                    cb->mpJoyButtonFunc(buttonsUp[i], Joystick::ButtonUp, cb->mpJoyFuncArgs);
                }
            }
        }
        joystick->mJoyCallbackMutex.Unlock();
#endif
    }
}


short int Joystick::GetAxisFromLetter(const char ch)
{
    short int result = 0;
    switch(tolower(ch))
    {
    case 'x':
        result = JOYSTICK_X_AXIS;
        break;
    case 'y':
        result = JOYSTICK_Y_AXIS;
        break;
    case 'z':
        result = JOYSTICK_Z_AXIS;
        break;
    case 'r':
        result = JOYSTICK_R_AXIS;
        break;
    case 'u':
        result = JOYSTICK_U_AXIS;
        break;
    case 'v':
        result = JOYSTICK_V_AXIS;
        break;
    default:
        result = 0;
        break;
    };

    return result;
}

char Joystick::GetLetterFromAxis(const short int axis)
{
    char result = 0;
    switch(axis)
    {
    case JOYSTICK_X_AXIS:
        result = 'X';
        break;
    case JOYSTICK_Y_AXIS:
        result = 'Y';
        break;
    case JOYSTICK_Z_AXIS:
        result = 'Z';
        break;
    case JOYSTICK_R_AXIS:
        result = 'R';
        break;
    case JOYSTICK_U_AXIS:
        result = 'U';
        break;
    case JOYSTICK_V_AXIS:
        result = 'V';
        break;
    default:
        result = 0;
        break;
    };

    return result;
}


#ifndef WIN32

void Joystick::CallbackThreadFunction(void* args)
{
    Joystick* joystick = (Joystick*)args;
    std::vector<int> buttonsDown;
    std::vector<int> buttonsUp;
    int prevButtons = 0;
    while(joystick && joystick->mCallbackThread.QuitThreadFlag() == false)
    {
        int curButtons;
        
        joystick->mJoystickMutex.Lock();
        curButtons = joystick->mButtons;
        joystick->mJoystickMutex.Unlock();
        
        buttonsDown.clear();
        buttonsUp.clear();
        
         // Now check for button events.
        for(unsigned int i = 0; i < MaxButtons; i++)
        {
            int mask = 1 << i;
            // Check for down
            if( (prevButtons&mask) == 0 && (curButtons&mask) > 0)
            {
                buttonsDown.push_back(i + 1);
            }
            // Check for up
            if( (prevButtons&mask) > 0 && (curButtons&mask) == 0)
            {
                buttonsUp.push_back(i + 1);
            }
        }
        
        prevButtons = curButtons;
        
        joystick->mJoyCallbackMutex.Lock();
        Callback::Data::List::iterator cb;
        for(cb = joystick->mCallbacks.begin();
            cb != joystick->mCallbacks.end();
            cb++)
        {
            if(cb->mpJoyCallback)
            {
                cb->mpJoyCallback->ProcessJoystickEvent(*joystick);
                for(unsigned int i = 0; i < (unsigned int)buttonsDown.size(); i++)
                {
                    cb->mpJoyCallback->ProcessButtonEvent(buttonsDown[i], Joystick::ButtonDown);
                }
                for(unsigned int i = 0; i < (unsigned int)buttonsUp.size(); i++)
                {
                    cb->mpJoyCallback->ProcessButtonEvent(buttonsUp[i], Joystick::ButtonUp);
                }
            }
            else if(cb->mpJoyFunc)
            {
                cb->mpJoyFunc(*joystick, cb->mpJoyFuncArgs);
            }
            else if(cb->mpJoyButtonFunc)
            {
                for(unsigned int i = 0; i < (unsigned int)buttonsDown.size(); i++)
                {
                    cb->mpJoyButtonFunc(buttonsDown[i], Joystick::ButtonDown, cb->mpJoyFuncArgs);
                }
                for(unsigned int i = 0; i < (unsigned int)buttonsUp.size(); i++)
                {
                    cb->mpJoyButtonFunc(buttonsUp[i], Joystick::ButtonUp, cb->mpJoyFuncArgs);
                }
            }
        }
        joystick->mJoyCallbackMutex.Unlock();

        unsigned int delay;
        delay = (unsigned int)(1000.0/(joystick->mUpdateFrequency + .000000000000000001));
        if(delay < 1)
        {
            delay = 1;         
        }
        SleepMs(delay);
    }
}

#endif


/*  End of File */