joystick.C

Ir a la documentación de este archivo.

//===========================================================================
//= joystick.cc                                           Noviembre de 1998 =
//=-------------------------------------------------------------------------=
//= Definiciones de las clase JOYSTICK*.                                    =
//=-------------------------------------------------------------------------=
//= ADVERTENCIA: ESTE SOFTWARE NO ESTA CONCEBIDO NI DISENNADO PARA EL USO   =
//= EN EQUIPO DE CONTROL EN LINEA EN ENTORNOS PELIGROSOS QUE REQUIERAN UN   =
//= DESEMPENNO LIBRE DE FALLAS, COMO LA OPERACION DE PLANTAS NUCLEARES,     = 
//= SISTEMAS DE NAVEGACION O COMUNICACION EN AVIONES, TRAFICO AEREO,        =
//= EQUIPO MEDICO DEL CUAL DEPENDAN VIDAS HUMANAS O SISTEMAS DE ARMAMENTO,  =
//= EN LOS CUALES UNA FALLA EN EL SOFTWARE PUEDA IMPLICAR DIRECTAMENTE LA   =
//= MUERTE, DANNOS PERSONALES O DANNOS FISICOS Y/O AMBIENTALES GRAVES       =
//= ("ACTIVIDADES DE ALGO RIESGO").                                         =
//=-------------------------------------------------------------------------=
//= Autor original: Oscar J. Chavarro G.  A.K.A. JEDILINK. Copyright (c),   =
//= 1997 - 2003, oscarchavarro@hotmail.com                                  =
//= AQUYNZA es software libre, y se rige bajo los terminos de la licencia   =
//= LGPL de GNU (http://www.gnu.org). Para mayor informacion respecto a la  =
//= licencia de uso, consulte el archivo ./doc/LICENCIA en la distribucion. =
//===========================================================================

#include "toolkits/media/joystick.h"

#if PLATAFORMA == i386_WIN32_VC
    #include <dinput.h>
    #include <assert.h>
    #include <malloc.h>
#endif

#include <string.h>
#include <stdlib.h>

//===========================================================================
//= Operaciones especificas de i386_WIN32_VC                                     =
//===========================================================================

#if PLATAFORMA == i386_WIN32_VC

static LONG WINAPI
receptor_eventos_nulo(HWND w, UINT tipo_mensaje, UINT uParam, LONG lParam)
{
    return DefWindowProc(w, tipo_mensaje, uParam, lParam);
}

static HWND
crear_ventana_joystick(void)
{
    static int lista = 0;
    static HWND receptora = NULL;

    if ( lista ) return receptora;

    //- CREE LA CLASE DE VENTANA RECEPTORA DE EVENTOS ------------
    // OJO: Jugar con lo siguiente en el STYLE: CS_BYTEALIGNCLIENT,
    // CS_BYTEALIGNWINDOW, CS_DBLCLKS, CS_NOCLOSE
    WNDCLASS atributos_de_ventana = {
        CS_GLOBALCLASS,     // UINT    style; 
        (WNDPROC)receptor_eventos_nulo,  // WNDPROC lpfnWndProc; 
        0,                  // int     cbClsExtra; 
        0,                  // int     cbWndExtra; 
        0,                  // HANDLE  hInstance; 
        NULL,               //HICON   hIcon; 
        NULL,               //HCURSOR hCursor; 
        NULL,               //HBRUSH  hbrBackground; 
        "",                 // Sin menu por defecto.
        "AQUYNZA_JOYSTICK_event_handler"    // LPCTSTR lpszClassName; 
    };

    if ( !RegisterClass(&atributos_de_ventana) ) {
        fprintf(stderr, "ERROR: No puedo crear la clase!\n");
        fflush(stdout);
        return NULL;
    }

    //- CREE LA VENTANA RECEPTORA ------------------------------
    receptora = CreateWindowEx( 
        WS_EX_NOPARENTNOTIFY | WS_EX_TRANSPARENT,
            // OJO: Revisar los "extended windows styles"
        "AQUYNZA_JOYSTICK_event_handler", // Nombre de la clase de ventana
        "AQUYNZA JOYSTICK event handler",  // Nombre de la ventana
        WS_ICONIC  | // Estilo de borde
        WS_CAPTION | WS_MINIMIZEBOX |WS_MAXIMIZEBOX | // Estilo de barra
        WS_CLIPSIBLINGS | WS_CLIPCHILDREN,  // Siempre activos!
        0, 0, 10, 10,  // Geometria de la ventana
        NULL, // Ventana padre: en este caso es la root-window
        NULL, // handle to menu (en este caso sin menu por defecto)
        0, // handle to application instance (ver parametro)
        (LPVOID)NULL // Apuntador a datos de mi aplicacion
    );

    if ( !receptora ) {
        fprintf(stderr,
            "ERROR: No pudo crearse la ventana receptora de eventos!\n");
        fflush(stderr);
    }

    lista = 1;
    ShowWindow(receptora, SW_SHOWDEFAULT);  // OJO: Esto no deberia ir!
        return receptora;
}

#endif

//===========================================================================
//= Clase JOYSTICK                                                          =
//===========================================================================

#ifndef JOYSTICK_ENABLED
JOYSTICK::JOYSTICK(char *)
{
    fprintf(stderr, "<JOYSTICK> - ERROR: No soportado en esta plataforma!\n");
    exit(-1);
}

JOYSTICK::~JOYSTICK()
{
    ;
}

BOOLEAN
JOYSTICK::abrir(void)
{
    return FALSE;
}

void
JOYSTICK::cerrar(void)
{
    ;
}

void
JOYSTICK::consultar(double *, double *, int *)
{
    ;
}

void
JOYSTICK::calibrar(void)
{
    ;
}

void
JOYSTICK::actualizar(void)
{
    ;
}

BOOLEAN
JOYSTICK::consultar_variable(const char *, int &, void **)
{
    return FALSE;
}

#endif

#ifdef JOYSTICK_ENABLED

JOYSTICK::JOYSTICK(
#ifdef UNIX_ENABLED
    char *filename
#endif
#if PLATAFORMA == i386_WIN32_VC
    char * /*filename*/
#endif
)
{
  #if PLATAFORMA == i386_LINUX_GCC || PLATAFORMA == SPARC64_LINUX_GCC
    archivo = filename;
    fd = -1;
  #endif

  #if PLATAFORMA == i386_WIN32_VC
    fd_device                             = NULL;
    direct_input_object                                 = NULL;
    gui_valido                           = FALSE;
  #endif

    fx = fy = 0;
}

JOYSTICK::~JOYSTICK()
{
    cerrar();
}


BOOLEAN
JOYSTICK::abrir(void)
{
  #if PLATAFORMA == i386_LINUX_GCC || PLATAFORMA == SPARC64_LINUX_GCC
    fd = open (archivo, O_RDONLY);
    if ( fd < 0 ) {
        fprintf(stderr, "<JOYSTICK> ERROR - Joystick no encontrado.\n");
        fflush(stderr);
        return FALSE;
    }
  #endif

#ifndef CBUILDER
#if PLATAFORMA == i386_WIN32_VC
  HWND hwndApp = crear_ventana_joystick();
  HRESULT hResult;
  cerrar();       // Make sure the device is in an uninitialized state

  // create the DirectInput object
  hResult = DirectInputCreate(i386_WIN32_VC_instancia_actual, DIRECTINPUT_VERSION, &direct_input_object, NULL);
  if (FAILED(hResult)) 
    return FALSE;

  // Use the DirectInput object to try to find an attached joystick. First we
  // restrict our search to force-feedback joysticks.
  hResult = direct_input_object->EnumDevices( 
                               DIDEVTYPE_JOYSTICK, 
                               (LPDIENUMDEVICESCALLBACK)device_callback, 
                               this, 
                               DIEDFL_ATTACHEDONLY | DIEDFL_FORCEFEEDBACK 
                               );
  if (FAILED(hResult))
    return FALSE;

  if (!gui_valido) {
    // Since we didn't get a force-feedback joystick, try to get any attached joystick
    hResult = direct_input_object->EnumDevices( 
                                 DIDEVTYPE_JOYSTICK, 
                                 (LPDIENUMDEVICESCALLBACK)device_callback, 
                                 this, 
                                 DIEDFL_ATTACHEDONLY 
                                 );

    if (FAILED(hResult))        
      return FALSE;
  }

  // If no joystick was found, we better abort
  if (!gui_valido) 
    return FALSE;

  LPDIRECTINPUTDEVICE lpDIDevice = NULL;

  // Create the device
  hResult = direct_input_object->CreateDevice(guid, &lpDIDevice, NULL);
  if (FAILED(hResult)) {
    fd_device = NULL;
    return FALSE;
  }

  // Get the device2 interface
  hResult = lpDIDevice->QueryInterface(IID_IDirectInputDevice2, (LPVOID *)&fd_device);
  if (FAILED(hResult)) 
    return FALSE;

  // Set the data format of the device to be a joystick.
  hResult = fd_device->SetDataFormat(&c_dfDIJoystick);
  if (FAILED(hResult)) 
    return FALSE;

  hResult = fd_device->SetCooperativeLevel(
                                           hwndApp,
                                           DISCL_EXCLUSIVE | DISCL_BACKGROUND);
  if (FAILED(hResult))
    return FALSE;

  // acquire the device
  hResult = fd_device->Acquire();
  if (FAILED(hResult)){
    fd_device->Release();
    direct_input_object->Release();
    return FALSE;
  }

  //-----------------------------------------------------------------------
  DIDEVICEINSTANCE didi;      
  didi.dwSize = sizeof DIDEVICEINSTANCE; 
  fd_device->GetDeviceInfo(&didi);
  //OutputString(didi.tszProductName);
  printf("%s encontrado!\n", didi.tszProductName); fflush(stdout);
  set_gain(50 /*START_GAIN*/);

  // colocar el rangoX
  DIPROPRANGE diprg;
  diprg.diph.dwSize       = sizeof(diprg);
  diprg.diph.dwHeaderSize = sizeof(diprg.diph); 
  diprg.diph.dwObj        = DIJOFS_X; 
  diprg.diph.dwHow        = DIPH_BYOFFSET; 
  diprg.lMin              = -1000; 
  diprg.lMax              = +1000; 
 
  fd_device->SetProperty(DIPROP_RANGE, &diprg.diph); 

  // colocar el rangoY
  diprg.diph.dwSize       = sizeof(diprg); 
  diprg.diph.dwHeaderSize = sizeof(diprg.diph); 
  diprg.diph.dwObj        = DIJOFS_Y; 
  diprg.diph.dwHow        = DIPH_BYOFFSET; 
  diprg.lMin              = -1000; 
  diprg.lMax              = +1000; 

  fd_device->SetProperty(DIPROP_RANGE, &diprg.diph); 

#endif // i386_WIN32_VC

#endif // CBUILDER

    return TRUE;
}

void
JOYSTICK::cerrar(void)
{
  #if PLATAFORMA == i386_LINUX_GCC || PLATAFORMA == SPARC64_LINUX_GCC
    close(fd);
  #endif

  #if PLATAFORMA == i386_WIN32_VC
    if (fd_device != NULL) {
        fd_device->Unacquire();
        fd_device->Release();
        fd_device = NULL;
    }
    if (direct_input_object != NULL) {
        direct_input_object->Release();
        direct_input_object = NULL;
    }
  #endif
}

void
JOYSTICK::consultar(double *x, double *y, int *botones)
{
    actualizar();
    (*x) = fx;
    (*y) = fy;
    (*botones) = fbotones;
}

void
JOYSTICK::actualizar(void)
{
  #if PLATAFORMA == i386_LINUX_GCC || PLATAFORMA == SPARC64_LINUX_GCC
    if ( fd < 0 ) return;

    status = read(fd, &lowlevel_data, JS_RETURN);
    if ( status != JS_RETURN ) {
        fprintf(stderr, "<JOYSTICK> ERROR leyendo datos.\n");
        fflush(stderr);
        exit(-1);
    }

    fx = (((double)(lowlevel_data.x-64))/128) - 0.5;
    fy = 0.5 - (((double)(lowlevel_data.y-64))/128);
    fbotones = lowlevel_data.buttons;
  #endif

  #if PLATAFORMA == i386_WIN32_VC
    fx = 0;
    fy = 0;
    fbotones = 0x0;

    HRESULT     hr ;
    DIJOYSTATE  diJoyState ;

    // No device object?  Give up.
    if( !fd_device ) return;

    // Poll, or retrieve information from the device
    hr = fd_device->Poll() ;
    if( hr== DIERR_INPUTLOST || hr== DIERR_NOTACQUIRED ) {
        // If the poll failed, maybe we should acquire
        fd_device->Acquire() ;

        // Lets try the poll again
        hr = fd_device->Poll() ;
    }
    if( FAILED(hr) ) return;

    // Get the device state, and populate the DIJOYSTATE structure
    if( FAILED(fd_device->GetDeviceState( sizeof(DIJOYSTATE), 
                                          & diJoyState)) ) {
        return;
    }

    int i;
    fbotones = 0x0;
    for ( i = 0; i < 8; i++ ) {
        if ( diJoyState.rgbButtons[i] ) {
            fbotones |= (0x01 << i);
        }
    }
    fx = (double)diJoyState.lX / 1000;
    fy = (double)diJoyState.lY / 1000;
    fy *= -1;
  #endif
}

static double TMP_double;

BOOLEAN
JOYSTICK::consultar_variable(const char *nombre_variable, int &tipo, void **ref)
{
    tipo = T_FLOAT;
    if ( strcmp(nombre_variable, "x") == 0 ) {
        TMP_double = fx;
        (*ref) = &TMP_double;
      }
      else if ( strcmp(nombre_variable, "y") == 0 ) {
        TMP_double = fy;
        (*ref) = &TMP_double;
      }
      else if ( strcmp(nombre_variable, "x1") == 0 ) {
        //printf("Reporto x1 = %.2f (%d)\n", fx, fbotones);  fflush(stdout);
        if ( !fbotones ) TMP_double = fx; else TMP_double = 0;
        (*ref) = &TMP_double;
      }
      else if ( strcmp(nombre_variable, "y1") == 0 ) {
        //printf("Reporto y1 = %.2f (%d)\n", fy, fbotones);  fflush(stdout);
        if ( !fbotones ) TMP_double = fy; else TMP_double = 0;
        (*ref) = &TMP_double;
      }
      else if ( strcmp(nombre_variable, "x2") == 0 ) {
        //printf("Reporto x2 = %.2f (%d)\n", fx, fbotones);  fflush(stdout);
        if ( fbotones == 0x01 ) TMP_double = fx; else TMP_double = 0;
        (*ref) = &TMP_double;
      }
      else if ( strcmp(nombre_variable, "y2") == 0 ) {
        //printf("Reporto y2 = %.2f (%d)\n", fy, fbotones);  fflush(stdout);
        if ( fbotones == 0x01 ) TMP_double = fy; else TMP_double = 0;
        (*ref) = &TMP_double;
      }
      else if ( strcmp(nombre_variable, "x3") == 0 ) {
        //printf("Reporto x3 = %.2f (%d)\n", fx, fbotones);  fflush(stdout);
        if ( fbotones == 0x02 ) TMP_double = fx; else TMP_double = 0;
        (*ref) = &TMP_double;
      }
      else if ( strcmp(nombre_variable, "y3") == 0 ) {
        //printf("Reporto y3 = %.2f (%d)\n", fy, fbotones);  fflush(stdout);
        if ( fbotones == 0x02 ) TMP_double = fy; else TMP_double = 0;
        (*ref) = &TMP_double;
      }
      else if ( strcmp(nombre_variable, "x4") == 0 ) {
        //printf("Reporto x4 = %.2f (%d)\n", fx, fbotones);  fflush(stdout);
        if ( fbotones == 0x03 ) TMP_double = fx; else TMP_double = 0;
        (*ref) = &TMP_double;
      }
      else if ( strcmp(nombre_variable, "y4") == 0 ) {
        //printf("Reporto y4 = %.2f (%d)\n", fy, fbotones);  fflush(stdout);
        if ( fbotones == 0x03 ) TMP_double = fy; else TMP_double = 0;
        (*ref) = &TMP_double;
      }
      else {
        return FALSE;
      }
    ;
    return TRUE;
}

#define CHECK() if (status == -1) {  perror ("jscal"); exit (1);  }

void
JOYSTICK::calibrar(void)
{
  #if PLATAFORMA == i386_LINUX_GCC || PLATAFORMA == SPARC64_LINUX_GCC
    int tmp;
    long tmpl;

    printf (
      "Mueva el joystick a la esquina superior izquierda y oprima un boton\n");
    while ( (read (fd, &lowlevel_data, JS_RETURN) > 0) && 
            lowlevel_data.buttons == 0x00 );
    while ( (read (fd, &lowlevel_data, JS_RETURN) > 0) && 
            lowlevel_data.buttons != 0x00 );

    status = ioctl(fd, JS_GET_TIMEOUT, &tmp);                 CHECK();
    //printf ("Timeout value = %d\n", tmp);

    status = ioctl(fd, JS_GET_TIMELIMIT, &tmpl);              CHECK();
    //printf ("Timelimit value = %ld ms\n", tmpl);

    //printf("Setting Timelimit = 10 ms\n");
    tmpl = 10;
    status = ioctl (fd, JS_SET_TIMELIMIT, &tmpl);             CHECK();

    status = ioctl (fd, JS_GET_CAL, &lowlevel_data);          CHECK();
  //printf ("Current correction: %d , %d\n", lowlevel_data.x, lowlevel_data.y);

    printf (
        "Mueva el joystick a la esquina inferior derecha y oprima un boton\n");
    while ( (read (fd, &lowlevel_data, JS_RETURN) > 0) && 
            lowlevel_data.buttons == 0x00 );

    for ( tmp = 0; lowlevel_data.x > 0xff;
          tmp++, lowlevel_data.x = lowlevel_data.x >> 1 );
    lowlevel_data.x = tmp;
    for ( tmp = 0; lowlevel_data.y > 0xff;
          tmp++, lowlevel_data.y = lowlevel_data.y >> 1 );
    lowlevel_data.y = tmp;

  //printf ("Setting correction: %d , %d\n", lowlevel_data.x, lowlevel_data.y);
    status = ioctl (fd, JS_SET_CAL, &lowlevel_data);          CHECK();

    status = ioctl (fd, JS_GET_CAL, &lowlevel_data);          CHECK();
  //printf ("Verify Correction (interrupt to exit): %d, %d\n",
  //        lowlevel_data.x,  lowlevel_data.y);

    printf("<JOYSTICK>: Calibracion terminada con exito.\n");
    fflush(stdout);
  #endif
}

#if PLATAFORMA == i386_WIN32_VC

BOOLEAN
JOYSTICK::set_gain(int gain)
{
  if ( ! direct_input_object  ||  ! fd_device )
    return FALSE;

  if ( (gain < 0) || (gain > 100) )
    return FALSE;

  // set the ForceFeedback gain
  DIPROPDWORD   propGain;
  propGain.diph.dwSize          = sizeof propGain;
  propGain.diph.dwHeaderSize    = sizeof propGain.diph;
  propGain.diph.dwHow                   = DIPH_DEVICE;
  propGain.diph.dwObj                   = 0;
  propGain.dwData                               = 100 * gain;

  HRESULT hRes = fd_device->SetProperty(DIPROP_FFGAIN, &propGain.diph);
  if (FAILED(hRes))
    return FALSE;

  return TRUE;
}

#ifndef CBUILDER
BOOLEAN
JOYSTICK::device_callback(LPDIDEVICEINSTANCE pdidi, LPVOID pv)
{
  // Return the first joystick we find. Our caller will restrict the
  // enumeration to force-feedback joysticks when appropriate.
  //
  // As a future enhancement, we could make a list of all joysticks
  // found and let the user choose which one to use.
  ((JOYSTICK *)pv)->guid = pdidi->guidInstance;
  ((JOYSTICK *)pv)->gui_valido = TRUE;

  return DIENUM_STOP;
}
#endif

#endif // i386_WIN32_VC

#endif // JOYSTICK_ENABLED

//===========================================================================
//= EOF                                                                     =
//===========================================================================

---

Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.