rnr::HIDXbox360 Class Reference

Xbox360 controller HID input class. More...

#include <HIDXbox360.h>

Inheritance diagram for rnr::HIDXbox360:

Classes
struct	UsbPkt_T
	USB application packet transfer structure. More...

Public Types
enum	ThreadState {   ThreadStateNone,   ThreadStateRunning,   ThreadStateExit }
	Update thread states. More...
enum	UsbPktId {   UsbPktIdInput = 0,   UsbPktIdRumble,   UsbPktIdLED,   UsbPktIdGoad,   UsbPktIdNumOf }
	USB transfer packet purpose. More...
Public Types inherited from rnr::HIDInput
typedef std::map< int, int >	FeatMap_T
	device feature id - mnemonic map More...

Public Member Functions
	HIDXbox360 (int usbDebugLevel=0)
	Default initialization constructor. More...
	~HIDXbox360 ()
	Destructor. More...
virtual int	getFeatureVal (int iMnem)
	Get the value associated with the mapped user mnemonic. More...
virtual int	setFeatureVal (int iMnem, int nVal)
	Set the value associated with the mapped user mnemonic. More...
virtual int	getFeatureProp (int iMnem, HIDFeatType &eFeatType, int &nDir, int &nMin, int &nMax, int &nStep)
	Get the feature properties. More...
virtual void *	getCurrentState ()
	Get the current full state of the device. More...
virtual bool	ping ()
	Ping device if it is connected and is responding. More...
virtual const char *	getStrError (int nError) const
	Get the string associated with the error number. More...
virtual int	open ()
	Open connection to an USB Xbox360 controller. More...
virtual int	close ()
	Close connection to an opened USB Xbox360 controller. More...
virtual int	run (float hz=30.0)
	Create and run USB update in thread. More...
virtual int	stop ()
	Stop and destroy USB update thread. More...
virtual int	update (uint_t uMSec=T_UPDATE_DFT)
	Read device and update HID state. More...
int	setRumble (int nLeftMot, int nRightMot)
	Set the rumble instensity. More...
int	setLED (int nPattern)
	Set the LED pattern. More...
void	calibrateJoySticks (int nLeftDeadZone, int nRightDeadZone)
	Set joysticks calibration. More...
void	setErrorThresholds (int nErrorRcvTimeoutTh=NErrorRcvTimeoutThDft, int nErrorRcvTh=NErrorRcvThDft, int nErrorTotalTh=NErrorTotalThDft)
	Set error count thresholds. More...
bool	isWireless ()
	Check if Xbox360 hardware is wireless. More...
void	debugPrintHdr ()
	Simple debug print header. More...
void	debugPrintState ()
	Simple debug print state. More...
Public Member Functions inherited from rnr::HIDInput
	HIDInput (HIDClass eHIDClass=HIDClassUnknown)
	Default initialization constructor. More...
virtual	~HIDInput ()
	Destructor. More...
virtual HIDClass	getHIDClass ()
	Get the HID class. More...
virtual bool	isConnected ()
	Query if HID is connected. More...
virtual bool	isLinked ()
	Query if HID is linked. More...
virtual int	assocFeature (int iFeatId, int iMnem)
	Associate user mnemonic to the device feature (e.g. button) id. More...
virtual bool	isFatal () const
	Test to see if HID is in a fatal errored state. More...
virtual int	getError () const
	Get the last HID-specific error number. More...
virtual std::string	getProdName ()
	Get HID product name. More...

Static Public Attributes
static const int	UsbTransferBufSize = 32
	Transfer buffer maximum byte size. More...
static const int	NErrorRcvTimeoutThDft = 0
	Consecutive receive timeouts threshold default. More...
static const int	NErrorRcvThDft = 5
	Consecutive receive errors threshold default. More...
static const int	NErrorTotalThDft = 0
	Total receive errors threshold default. More...
Static Public Attributes inherited from rnr::HIDInput
static const int	MNEM_START = 1024
	user mapped mnemonic starting index More...
static const int	T_UPDATE_DFT = 33
	default update timeout (msec) More...

Protected Member Functions
virtual void	setLinkState (bool bNewState)
	Set new link state. More...
int	openXbox ()
	Open Xbox360 connection. More...
int	claimXboxInterfaces ()
	Claim all Xbox USB interfaces. More...
int	initTransferPkts ()
	Allocate and initialize all USB transfer packets. More...
void	freeTransferPkts ()
	Free all USB transfer packets. More...
int	submitReadTransfer ()
	Submit read Xbox input asynchronous transfer. More...
void	flushInput ()
	Flush any pending input transfer buffers. More...
void	cancelTransfers ()
	Cancel all pending USB transfers. More...
void	goad ()
	Goad the Xbox360 to send a message. More...
bool	parseWireless (byte_t buf[], ssize_t n)
	Parse wireless Xbox360 input events. More...
bool	parseWired (byte_t buf[], ssize_t n)
	Parse wired Xbox360 input events. More...
void	updateButtonState (byte_t msg[], ssize_t n)
	Update the controller input button state. More...
void	updateRumbleState (byte_t msg[], ssize_t n)
	Update the rumble motors state. More...
void	updateLEDState (byte_t buf[], ssize_t n)
	Update the LED pattern state. More...
void	clearErrorCnts ()
	Clear error counts. More...
bool	checkErrorThresholds ()
	Check errors against thresholds. More...
void	zeroState ()
	Zero controller shadowed state. More...
int	updown (int nBit)
	Convert bit value to button up/down state. More...
int	convertToInt (byte_t lsb, byte_t msb)
	Convert two bytes to signed integer. More...
int	createUpdateThread ()
	Create USB update thread. More...
int	cancelUpdateThread ()
	Cancel (destroy) USB update thread. More...
void	lock ()
	Lock update thread. More...
void	unlock ()
	Unlock the update thread. More...
void	signalUpdateThread ()
	Signal update thread of change of state. More...
void	blockWait ()
	Blocked timed wait. More...
void	debugPrintTransferBuf (const std::string &strPreface, struct libusb_transfer *transfer)
	Debug print USB transfer buffer contents. More...
void	debugPrintTransferBuf (const std::string &strPreface, byte_t buf[], ssize_t n, const std::string &strEoR="\n")
	Debug print USB transfer buffer contents. More...
Protected Member Functions inherited from rnr::HIDInput
virtual void	setConnectionState (bool bNewState)
	Set connection state. More...

Static Protected Member Functions
static void	transferCallbackInput (struct libusb_transfer *transfer)
	Input transfer function callback. More...
static void	transferCallbackRumble (struct libusb_transfer *transfer)
	Write rumble motor values transfer function callback. More...
static void	transferCallbackLED (struct libusb_transfer *transfer)
	Write LED pattern transfer function callback. More...
static void	transferCallbackGoad (struct libusb_transfer *transfer)
	Write packet to force a response packet from the Xbox360. More...
static void *	updateThread (void *pArg)
	The update thread. More...

Protected Attributes
int	m_nProdId
	Xbox USB product id. More...
std::string	m_strProdName
	product name More...
std::string	m_strSerialNum
	serial number More...
int	m_nBatteryStatus
	batter status More...
int	m_nStatus
	raw status byte More...
int	m_nOffset
	start offset in message More...
int	m_nLeftJoyDeadZone
	left joystick deadzone More...
float	m_fLeftJoyM
	left joystick slope More...
float	m_fLeftJoyB
	left joystick y intercept More...
int	m_nRightJoyDeadZone
	right joystick deadzone More...
float	m_fRightJoyM
	right joystick slope More...
float	m_fRightJoyB
	right joystick y intercept More...
int	m_state [Xbox360FeatIdNumOf]
	current state More...
int	m_nLEDPattern
	target LED pattern More...
int	m_nLeftRumble
	target left rumble intensity More...
int	m_nRightRumble
	target right rumble intensity More...
int	m_nErrorRcv
	consecutive rcv error count More...
int	m_nErrorRcvTh
	consec rcv error threshold More...
int	m_nErrorRcvTimeout
	consec rcv timeout error cnt More...
int	m_nErrorRcvTimeoutTh
	consec rcv timeout error th More...
int	m_nErrorSend
	consec send error count More...
int	m_nErrorTotal
	total error count More...
int	m_nErrorTotalTh
	total error threshold More...
struct libusb_context *	m_usbContext
	libusb session context More...
struct libusb_device_handle *	m_usbHandle
	USB open handle. More...
UsbPkt_T	m_usbPkt [UsbPktIdNumOf]
	USB transfer packets. More...
ThreadState	m_eThreadState
	update thread state More...
struct timespec	m_tsThread
	update thread period More...
pthread_mutex_t	m_mutexUpdate
	mutex More...
pthread_cond_t	m_condUpdate
	condition More...
pthread_t	m_threadId
	update pthread identifier More...
Protected Attributes inherited from rnr::HIDInput
HIDClass	m_eHIDClass
	actual HID class More...
std::string	m_strProdName
	product name More...
bool	m_bIsConnected
	HID is [not] physically connected. More...
bool	m_bIsLinked
	HID is [not] linked and communicating. More...
int	m_nError
	last error number (HID specific) More...
bool	m_bFatal
	HID is [not] in a fatal condition. More...
FeatMap_T	m_featMap
	feature-userid association map More...

Detailed Description

Xbox360 controller HID input class.

Definition at line 651 of file HIDXbox360.h.

Member Enumeration Documentation

enum rnr::HIDXbox360::ThreadState

Update thread states.

Enumerator
ThreadStateNone	no thread
ThreadStateRunning	thread running
ThreadStateExit	thread to exit

Definition at line 669 of file HIDXbox360.h.

    {
      ThreadStateNone,      ///< no thread
      ThreadStateRunning,   ///< thread running
      ThreadStateExit       ///< thread to exit
    };

enum rnr::HIDXbox360::UsbPktId

USB transfer packet purpose.

Enumerator
UsbPktIdInput	normal input (read) transfer packet
UsbPktIdRumble	rumble (write) transfer packet
UsbPktIdLED	LED (write) transfer packet.
UsbPktIdGoad	Goad (write) transfer packet.
UsbPktIdNumOf	number of transfer packet ids

Definition at line 679 of file HIDXbox360.h.

    {
      UsbPktIdInput = 0,    ///< normal input (read) transfer packet
      UsbPktIdRumble,       ///< rumble (write) transfer packet
      UsbPktIdLED,          ///< LED (write) transfer packet
      UsbPktIdGoad,         ///< Goad (write) transfer packet
      UsbPktIdNumOf         ///< number of transfer packet ids
    } UsbPktId;

Constructor & Destructor Documentation

HIDXbox360::HIDXbox360

(

int

usbDebugLevel = 0

)

Default initialization constructor.

Definition at line 80 of file HIDXbox360.cxx.

References calibrateJoySticks(), clearErrorCnts(), rnr::HIDXbox360::UsbPkt_T::m_bCancel, rnr::HIDInput::m_bFatal, rnr::HIDXbox360::UsbPkt_T::m_bHasSubmitted, m_condUpdate, m_eThreadState, rnr::HIDInput::m_featMap, m_mutexUpdate, m_nBatteryStatus, rnr::HIDInput::m_nError, m_nLEDPattern, m_nLeftRumble, m_nOffset, m_nProdId, m_nRightRumble, m_nStatus, m_usbContext, m_usbHandle, m_usbPkt, rnr::HIDXbox360::UsbPkt_T::m_usbTransfer, setErrorThresholds(), ThreadStateNone, UsbPktIdNumOf, XBOX360_LED_PAT_ALL_BLINK, XBOX360_LEFT_DEAD_ZONE, XBOX360_NO_PROD_ID, XBOX360_RIGHT_DEAD_ZONE, rnr::Xbox360FeatIdNumOf, rnr::Xbox360FeatIdPadUp, and zeroState().

                                        : HIDInput(HIDClassXbox360)
{ 
  int   i;

  //
  // HID state
  //
  m_nProdId         = XBOX360_NO_PROD_ID;
  m_nBatteryStatus  = 0;
  m_nStatus         = 0;
  m_nOffset         = 0;

  calibrateJoySticks(XBOX360_LEFT_DEAD_ZONE, XBOX360_RIGHT_DEAD_ZONE);

  zeroState();

  m_nLEDPattern   = XBOX360_LED_PAT_ALL_BLINK;
  m_nLeftRumble   = 0;
  m_nRightRumble  = 0;

  for(i=Xbox360FeatIdPadUp; i<Xbox360FeatIdNumOf; ++i)
  {
    m_featMap[i] = i;
  }

  // set error thresholds defaults and clear error counts
  setErrorThresholds();
  clearErrorCnts();

  //
  // USB data
  //
  m_usbContext  = NULL;
  m_usbHandle   = NULL;

  for(i=0; i<UsbPktIdNumOf; ++i)
  {
    m_usbPkt[i].m_usbTransfer   = NULL;
    m_usbPkt[i].m_bHasSubmitted = false;
    m_usbPkt[i].m_bCancel       = false;
  }

  pthread_mutex_init(&m_mutexUpdate, NULL);
  pthread_cond_init(&m_condUpdate,   NULL);
  m_eThreadState = ThreadStateNone;

  // initialize the libusb library, setting context
  if( m_nError = libusb_init(&m_usbContext) != LIBUSB_SUCCESS )
  {
    LOGERROR("libusb_init() failed: %s.", libusb_error_name(m_nError));
    m_usbContext = NULL;
    m_bFatal = true;
  }

  // set debug level
  else
  {
    libusb_set_debug(m_usbContext, usbDebugLevel);
  }
}

HIDXbox360::~HIDXbox360

(

)

Destructor.

Definition at line 141 of file HIDXbox360.cxx.

References close(), rnr::HIDInput::m_bIsConnected, m_condUpdate, m_mutexUpdate, and m_usbContext.

{
  if( m_bIsConnected )
  {
    close();
  }

  pthread_cond_destroy(&m_condUpdate);
  pthread_mutex_destroy(&m_mutexUpdate);

  // exit libusb
  if( m_usbContext != NULL )
  {
    libusb_exit(m_usbContext);
    m_usbContext = NULL;
  }
}

Member Function Documentation

void HIDXbox360::blockWait ( )

protected

Blocked timed wait.

Context:

Update thread.

Definition at line 1860 of file HIDXbox360.cxx.

References lock(), m_condUpdate, m_mutexUpdate, m_tsThread, and unlock().

Referenced by unlock(), and updateThread().

{
  lock();
  pthread_cond_timedwait(&m_condUpdate, &m_mutexUpdate, &m_tsThread);
  unlock();
}

void HIDXbox360::calibrateJoySticks	(	int	nLeftDeadZone,
		int	nRightDeadZone
	)

Set joysticks calibration.

For each joystick, there exist a deadzone near the center that should be treated as zero due to hardware induced noise. Each stick output is calibrated as illustrated:

*
*      Uncalibrated                      DeadZone Calibrated
*     |                                 |
* max -          .                  max -          .
*     |        .                        |         .
*     |      .                          |       .
*     |    .             ==>            |      .
*     |  .                              |     .
*     |.                                |    .
*   0 +----------|--                  0 +....------|--
*               max                        dz     max
*
*
* 

Definition at line 741 of file HIDXbox360.cxx.

References m_fLeftJoyB, m_fLeftJoyM, m_fRightJoyB, m_fRightJoyM, m_nLeftJoyDeadZone, and m_nRightJoyDeadZone.

Referenced by getStrError(), and HIDXbox360().

{
  float fMax = (float)numeric_limits<int16_t>::max();

  m_nLeftJoyDeadZone  = nLeftDeadZone;
  m_fLeftJoyM         = fMax / (float)(fMax - m_nLeftJoyDeadZone);
  m_fLeftJoyB         = (float)(-m_nLeftJoyDeadZone) * m_fLeftJoyM;

  m_nRightJoyDeadZone = nRightDeadZone;
  m_fRightJoyM        = (float)fMax / (float)(fMax - m_nRightJoyDeadZone);
  m_fRightJoyB        = (float)(-m_nRightJoyDeadZone) * m_fRightJoyM;
}

void HIDXbox360::cancelTransfers ( )

protected

Cancel all pending USB transfers.

Definition at line 1340 of file HIDXbox360.cxx.

References rnr::HIDXbox360::UsbPkt_T::m_bCancel, m_usbPkt, update(), and UsbPktIdNumOf.

Referenced by close().

{
  int   nMaxTries = 5;
  int   nTries;
  int   nTrans;
  int   i;

  for(i=0; i<UsbPktIdNumOf; ++i)
  {
    m_usbPkt[i].m_bCancel = true;
  }

  for(nTries=0; nTries<nMaxTries; ++nTries)
  {
    update();

    for(i=0, nTrans=0; i<UsbPktIdNumOf; ++i)
    {
      if( !m_usbPkt[i].m_bHasSubmitted )
      {
        ++nTrans;
      }
    }

    if( nTrans == UsbPktIdNumOf )
    {
      return;
    }
  }
}

int HIDXbox360::cancelUpdateThread ( )

protected

Cancel (destroy) USB update thread.

Returns

Returns 0 on success, < 0 on failure.

Definition at line 1845 of file HIDXbox360.cxx.

References m_eThreadState, m_threadId, signalUpdateThread(), and ThreadStateExit.

Referenced by stop(), and updown().

{
  m_eThreadState = ThreadStateExit;
  signalUpdateThread();
  usleep(1000);
  pthread_cancel(m_threadId);
  pthread_join(m_threadId, NULL);
  return 0;
}

bool HIDXbox360::checkErrorThresholds ( )

protected

Check errors against thresholds.

If any of the error counts exceed their respective thresholds, then the connection state is automatically transitioned to the 'no link' state.

Returns

Returns true if link is good, else false.

Definition at line 1787 of file HIDXbox360.cxx.

References rnr::HIDInput::m_bIsLinked, m_nErrorRcv, m_nErrorRcvTh, m_nErrorRcvTimeout, m_nErrorRcvTimeoutTh, m_nErrorTotal, m_nErrorTotalTh, and setLinkState().

Referenced by clearErrorCnts(), and transferCallbackInput().

{
  if( !m_bIsLinked )
  {
    return m_bIsLinked;
  }

  //
  // Receive timeout threshold.
  //
  if((m_nErrorRcvTimeoutTh > 0) && (m_nErrorRcvTimeout > m_nErrorRcvTimeoutTh))
  {
    LOGERROR("Consecutive received timeout error count %d "
             "exceeds threshold %d.", m_nErrorRcvTimeout, m_nErrorRcvTimeoutTh);
    ++m_nErrorRcv;
    ++m_nErrorTotal;
    setLinkState(false);
  }

  //
  // Receive error threshold.
  //
  if( (m_nErrorRcvTh > 0) && (m_nErrorRcv > m_nErrorRcvTh) )
  {
    LOGERROR("Consecutive received error count %d exceeds threshold %d.",
        m_nErrorRcv, m_nErrorRcvTh);
    setLinkState(false);
  }

  //
  // Total receive error threshold.
  //
  if( (m_nErrorTotalTh > 0) && (m_nErrorTotal > m_nErrorTotalTh) )
  {
    LOGERROR("Total received error count %d exceeds threshold %d.",
        m_nErrorTotal, m_nErrorTotalTh);
    setLinkState(false);
  }

  return m_bIsLinked;
}

int HIDXbox360::claimXboxInterfaces ( )

protected

Claim all Xbox USB interfaces.

Any any kernel claimed drivers will be detached.

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Definition at line 861 of file HIDXbox360.cxx.

References rnr::HIDInput::m_nError, m_nProdId, m_usbHandle, XBOX360_NUM_OF_INTERFACES, XBOX360_TETHERED_PROD_ID, and XBOX360_WIRED_PROD_ID.

Referenced by openXbox().

{
  int   i;
  int   status;
  int   interfaces = 0;

  interfaces = XBOX360_NUM_OF_INTERFACES;

  //
  // RAS: Set all other interface values here
  //

  //
  // Detach any kernel drivers already attached to Xbox.
  //
  for(i=0; i<interfaces; ++i)
  {
    status = libusb_kernel_driver_active(m_usbHandle, i);
    
    // attached, so detach
    if( status > 0 )
    {
      m_nError = libusb_detach_kernel_driver(m_usbHandle, i);
      if( m_nError < 0 )
      {
        LOGERROR("libusb_detach_kernel_driver() failed: %s.",
            libusb_error_name(m_nError));
        return m_nError;
      }
    }
    else if( status < 0 )
    {
      m_nError = status;
      LOGERROR("libusb_kernel_driver_active() failed: %s.",
            libusb_error_name(m_nError));
      return m_nError;
    }
  }

  //
  // Set active configuration for Xbox, performing light-weight reset if
  // necessary.
  //
  if( (m_nProdId == XBOX360_WIRED_PROD_ID) ||
      (m_nProdId == XBOX360_TETHERED_PROD_ID) )
  {
    m_nError = libusb_set_configuration(m_usbHandle, 1);
    if( m_nError < 0 )
    {
      LOGERROR("libusb_set_configuration() failed: %s.",
          libusb_error_name(m_nError));
      return m_nError;
    }
  }

  //
  // Claim the Xbox interfaces.
  //
  for(i=0; i<interfaces; ++i)
  {
    m_nError = libusb_claim_interface(m_usbHandle, i);
    if( m_nError < 0 )
    {
      LOGERROR("libusb_claim_interface() failed: %s.",
          libusb_error_name(m_nError));
      return m_nError;
    }
  }

  return LIBUSB_SUCCESS;
}

void rnr::HIDXbox360::clearErrorCnts ( )

inlineprotected

Clear error counts.

Definition at line 1133 of file HIDXbox360.h.

References checkErrorThresholds().

Referenced by HIDXbox360(), and open().

    {
      m_nErrorRcvTimeout  = 0;
      m_nErrorRcv         = 0;
      m_nErrorSend        = 0;
      m_nErrorTotal       = 0;
    }

int HIDXbox360::close ( )

virtual

Close connection to an opened USB Xbox360 controller.

All interface will be released.

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Implements rnr::HIDInput.

Definition at line 230 of file HIDXbox360.cxx.

References cancelTransfers(), freeTransferPkts(), rnr::HIDInput::m_bFatal, rnr::HIDInput::m_nError, m_nProdId, m_nStatus, m_state, m_strProdName, m_strSerialNum, m_usbContext, m_usbHandle, rnr::HIDInput::setConnectionState(), setLinkState(), stop(), XBOX360_NO_PROD_ID, XBOX360_NUM_OF_INTERFACES, rnr::Xbox360FeatIdLeftRumble, rnr::Xbox360FeatIdRightRumble, and zeroState().

Referenced by getStrError(), main(), open(), openXbox(), testXboxSanity(), and ~HIDXbox360().

{
  // in fatal condition and/or libusb not initialzed
  if( m_bFatal || (m_usbContext == NULL) )
  {
    LOGERROR("libusb not initialized.");
    return m_nError;
  }

  //
  // Close
  //
  if( m_usbHandle != NULL )
  {
    // put Xbox in a good state
    if( (m_state[Xbox360FeatIdLeftRumble] != 0) ||
        (m_state[Xbox360FeatIdRightRumble] != 0) )
    {
      //setRumble(0, 0);
      //usleep(10000);
    }

    // stop update thread
    stop();

    // cancel any pending transfers
    cancelTransfers();

    // free all transfer packet memory
    freeTransferPkts();

    libusb_reset_device(m_usbHandle);   

    // release claimed interfaces
    for(int i=0; i<XBOX360_NUM_OF_INTERFACES; ++i)
    {
      if( (m_nError = libusb_release_interface(m_usbHandle, i)) < 0 )
      {
        LOGWARN("libusb_release_interface() failed: %s.",
            libusb_error_name(m_nError));
      }
    }

    // close USB opened device
    libusb_close(m_usbHandle);

    LOGDIAG3("Closed Xbox360 controller (product id=0x%04x).", m_nProdId);
  }

  // zap state
  zeroState();
  m_usbHandle     = NULL;
  setConnectionState(false);
  setLinkState(false);
  m_nProdId       = XBOX360_NO_PROD_ID;
  m_strProdName.clear();
  m_strSerialNum.clear();
  m_nStatus       = 0;

  return LIBUSB_SUCCESS;
}

int HIDXbox360::convertToInt ( byte_t  lsb, byte_t  msb  )

protected

Convert two bytes to signed integer.

Parameters

lsb	Least significant byte.
msb	Most significant byte.

Returns

Converted integer value.

Definition at line 1773 of file HIDXbox360.cxx.

Referenced by updateButtonState(), updateRumbleState(), and updown().

{
  int output;

  output = (int)( (((uint_t)msb) << 8) | (uint_t)lsb);

  if( output & 0x8000 )
  {
    output -= 0xffff;
  }

  return output;
}

int HIDXbox360::createUpdateThread ( )

protected

Create USB update thread.

Returns

Returns 0 on success, < 0 on failure.

Definition at line 1829 of file HIDXbox360.cxx.

References m_eThreadState, m_threadId, ThreadStateRunning, and updateThread().

Referenced by run(), and updown().

{
  int   rc;

  m_eThreadState = ThreadStateRunning;

  rc = pthread_create(&m_threadId, NULL, HIDXbox360::updateThread, (void*)this);
 
  if( rc < 0 )
  {
    LOGSYSERROR("pthread_create()");
  }

  return rc;
}

void HIDXbox360::debugPrintHdr

(

)

Simple debug print header.

Definition at line 1928 of file HIDXbox360.cxx.

References m_nProdId, and m_strProdName.

Referenced by isWireless(), main(), testXboxInput(), testXboxLED(), and testXboxRumble().

{
  fprintf(stderr,
"                            %s (Product Id 0x%04x)"
"\n"
" DPad     Bump  Bk Cx St  A B X Y    Trigger   LeftJoyStick     RightJoytStick"
"    LED  Rumble   Link Status Batt  ERTO  ER  ES  ETOT"
"\n", m_strProdName.c_str(), m_nProdId);
//"1 1 1 1   0 0   1  1  1   1 1 1 1   255 255  1 -32333 -32333  1 -32333 -32333
//    0xhh false  127  10 100
}

void HIDXbox360::debugPrintState

(

)

Simple debug print state.

Definition at line 1940 of file HIDXbox360.cxx.

References rnr::HIDInput::m_bIsLinked, m_nBatteryStatus, m_nErrorRcv, m_nErrorRcvTimeout, m_nErrorSend, m_nErrorTotal, m_nStatus, m_state, rnr::Xbox360FeatIdAButton, rnr::Xbox360FeatIdBack, rnr::Xbox360FeatIdBButton, rnr::Xbox360FeatIdCenterX, rnr::Xbox360FeatIdLEDPat, rnr::Xbox360FeatIdLeftBump, rnr::Xbox360FeatIdLeftJoyX, rnr::Xbox360FeatIdLeftJoyY, rnr::Xbox360FeatIdLeftRumble, rnr::Xbox360FeatIdLeftStickClick, rnr::Xbox360FeatIdLeftTrigger, rnr::Xbox360FeatIdPadDown, rnr::Xbox360FeatIdPadLeft, rnr::Xbox360FeatIdPadRight, rnr::Xbox360FeatIdPadUp, rnr::Xbox360FeatIdRightBump, rnr::Xbox360FeatIdRightJoyX, rnr::Xbox360FeatIdRightJoyY, rnr::Xbox360FeatIdRightRumble, rnr::Xbox360FeatIdRightStickClick, rnr::Xbox360FeatIdRightTrigger, rnr::Xbox360FeatIdStart, rnr::Xbox360FeatIdXButton, and rnr::Xbox360FeatIdYButton.

Referenced by isWireless(), main(), testXboxInput(), testXboxLED(), and testXboxRumble().

{
  fprintf(stderr,
    "%1d %1d %1d %1d   %1d %1d   %1d  %1d  %1d   %1d %1d %1d %1d   %3d %3d   "
    "%1d %6d %6d   %1d %6d %6d    %2d %3d %3d  %5s   0x%02x %4d %5d %3d %3d %5d\r",
        m_state[Xbox360FeatIdPadUp],
        m_state[Xbox360FeatIdPadDown],
        m_state[Xbox360FeatIdPadLeft],
        m_state[Xbox360FeatIdPadRight],

        m_state[Xbox360FeatIdLeftBump],
        m_state[Xbox360FeatIdRightBump],

        m_state[Xbox360FeatIdBack],
        m_state[Xbox360FeatIdCenterX],
        m_state[Xbox360FeatIdStart],

        m_state[Xbox360FeatIdAButton],
        m_state[Xbox360FeatIdBButton],
        m_state[Xbox360FeatIdXButton],
        m_state[Xbox360FeatIdYButton],

        m_state[Xbox360FeatIdLeftTrigger],
        m_state[Xbox360FeatIdRightTrigger],

        m_state[Xbox360FeatIdLeftStickClick],
        m_state[Xbox360FeatIdLeftJoyX],
        m_state[Xbox360FeatIdLeftJoyY],
        m_state[Xbox360FeatIdRightStickClick],
        m_state[Xbox360FeatIdRightJoyX],
        m_state[Xbox360FeatIdRightJoyY],
          
        m_state[Xbox360FeatIdLEDPat],
        m_state[Xbox360FeatIdLeftRumble],
        m_state[Xbox360FeatIdRightRumble],

        (m_bIsLinked? "true": "false"),
        m_nStatus,
        m_nBatteryStatus,
        m_nErrorRcvTimeout,
        m_nErrorRcv,
        m_nErrorSend,
        m_nErrorTotal);

  fflush(stderr);
}

void rnr::HIDXbox360::debugPrintTransferBuf ( const std::string &  strPreface, struct libusb_transfer *  transfer  )

inlineprotected

Debug print USB transfer buffer contents.

Parameters

strPreface	User identifying preface string.
tranfer	Pointer to USB transfer buffer.

Definition at line 1256 of file HIDXbox360.h.

    {
      debugPrintTransferBuf(strPreface, transfer->buffer,
                                        transfer->actual_length);
    }

void HIDXbox360::debugPrintTransferBuf ( const std::string &  strPreface, byte_t  buf[], ssize_t  n, const std::string &  strEoR = "\n"  )

protected

Debug print USB transfer buffer contents.

Parameters

strPreface	User identifying preface string.
buf	USB data buffer.
n	USB data buffer length

Definition at line 1987 of file HIDXbox360.cxx.

{
  struct timeval  tvNow;
  double          t;

  gettimeofday(&tvNow, NULL);

  t = (double)tvNow.tv_sec + (double)tvNow.tv_usec / 1000000.0;

  fprintf(stderr, "%.3lf ", t);

  if( !strPreface.empty() )
  {
    fprintf(stderr, "%s: ", strPreface.c_str());
  }

  fprintf(stderr, "buf_len=%zd: ", n);

  for(int i=0; i<n; ++i)
  {
    fprintf(stderr, "%02x ", buf[i]);
  }

  fprintf(stderr, "%s", strEoR.c_str());
  fflush(stderr);
}

void HIDXbox360::flushInput ( )

protected

Flush any pending input transfer buffers.

Definition at line 1371 of file HIDXbox360.cxx.

References update().

Referenced by open().

{
  static int    nMaxTries = 5;

  for(int i=0; i<nMaxTries; ++i)
  {
    update();
  }
}

void HIDXbox360::freeTransferPkts ( )

protected

Free all USB transfer packets.

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Definition at line 999 of file HIDXbox360.cxx.

References m_usbPkt, rnr::HIDXbox360::UsbPkt_T::m_usbTransfer, and UsbPktIdNumOf.

Referenced by close().

{
  for(int i=0; i<UsbPktIdNumOf; ++i)
  {
    if( m_usbPkt[i].m_usbTransfer == NULL )
    {
      continue;
    }
    else if( m_usbPkt[i].m_bHasSubmitted )
    {
      LOGWARN("USB transfer packet %d has been submitted - cannot free.", i);
    }
    else
    {
      libusb_free_transfer(m_usbPkt[i].m_usbTransfer);
      m_usbPkt[i].m_usbTransfer = NULL;
    }
  }
}

virtual void* rnr::HIDXbox360::getCurrentState ( )

inlinevirtual

Get the current full state of the device.

Returns

Return (int *) pointer to the device-specific input state.

Reimplemented from rnr::HIDInput.

Definition at line 770 of file HIDXbox360.h.

References m_state, and ping().

{ return m_state; }

int HIDXbox360::getFeatureProp ( int  iMnem, HIDFeatType &  eFeatType, int &  nDir, int &  nMin, int &  nMax, int &  nStep  )

virtual

Get the feature properties.

Parameters

	iMnem	User-specific mnemonic.
[out]	eFeatType	Feature property type.
[out]	nDir	Feature is an input (HID_FEAT_INPUT) to host and/or an output (HID_FEAT_OUTPUT) to device.
[out]	nMin	Feature minimum value.
[out]	nMax	Feature maximum value.
[out]	nStep	Feature step size between [min,max]

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Implements rnr::HIDInput.

Definition at line 353 of file HIDXbox360.cxx.

References HID_BTTN_DOWN, HID_BTTN_UP, HID_FEAT_INPUT, HID_FEAT_OUTPUT, rnr::HIDFeatTypeBiState, rnr::HIDFeatTypeEnum, rnr::HIDFeatTypeRange, rnr::HIDInput::m_featMap, XBOX360_LED_PAT_ALL_BLINK, XBOX360_LED_PAT_ALL_OFF, rnr::Xbox360FeatIdLEDPat, rnr::Xbox360FeatIdLeftJoyX, rnr::Xbox360FeatIdLeftJoyY, rnr::Xbox360FeatIdLeftRumble, rnr::Xbox360FeatIdLeftTrigger, rnr::Xbox360FeatIdRightJoyX, rnr::Xbox360FeatIdRightJoyY, rnr::Xbox360FeatIdRightRumble, and rnr::Xbox360FeatIdRightTrigger.

Referenced by getFeatureVal().

{
  FeatMap_T::iterator pos;

  if( (pos = m_featMap.find(iMnem)) == m_featMap.end() )
  {
    return LIBUSB_ERROR_INVALID_PARAM;
  }

  switch( pos->second )
  {
    case Xbox360FeatIdLeftJoyX:
    case Xbox360FeatIdLeftJoyY:
    case Xbox360FeatIdRightJoyX:
    case Xbox360FeatIdRightJoyY:
      eFeatType = HIDFeatTypeRange;
      nDir      = HID_FEAT_INPUT;
      nMin      = numeric_limits<int16_t>::min();
      nMax      = numeric_limits<int16_t>::max();
      nStep     = 1;
      break;
    case Xbox360FeatIdLeftTrigger:
    case Xbox360FeatIdRightTrigger:
      eFeatType = HIDFeatTypeRange;
      nDir      = HID_FEAT_INPUT;
      nMin      = 0;
      nMax      = numeric_limits<int8_t>::max();
      nStep     = 1;
      break;
    case Xbox360FeatIdLeftRumble:
    case Xbox360FeatIdRightRumble:
      eFeatType = HIDFeatTypeRange;
      nDir      = HID_FEAT_OUTPUT;
      nMin      = 0;
      nMax      = numeric_limits<int8_t>::max();
      nStep     = 1;
      break;
    case Xbox360FeatIdLEDPat:
      eFeatType = HIDFeatTypeEnum;
      nDir      = HID_FEAT_INPUT | HID_FEAT_OUTPUT;
      nMin      = XBOX360_LED_PAT_ALL_OFF;
      nMax      = XBOX360_LED_PAT_ALL_BLINK;
      nStep     = 1;
      break;
    default:
      eFeatType = HIDFeatTypeBiState;
      nDir      = HID_FEAT_INPUT;
      nMin      = HID_BTTN_UP;
      nMax      = HID_BTTN_DOWN;
      nStep     = 1;
      break;
  }

  return LIBUSB_SUCCESS;
}

virtual int rnr::HIDXbox360::getFeatureVal ( int  iMnem )

inlinevirtual

Get the value associated with the mapped user mnemonic.

Parameters

iMnem

User-specific mnemonic.

Returns

Feature current value.

Implements rnr::HIDInput.

Definition at line 720 of file HIDXbox360.h.

References getFeatureProp(), rnr::HIDInput::m_featMap, m_state, and setFeatureVal().

Referenced by main(), testXboxInput(), testXboxLED(), and testXboxRumble().

    {
      FeatMap_T::iterator pos;

      if( (pos = m_featMap.find(iMnem)) != m_featMap.end() )
      {
        return m_state[pos->second];
      }
      else
      {
        return -1;
      }
    }

virtual const char* rnr::HIDXbox360::getStrError ( int  nError ) const

inlinevirtual

Get the string associated with the error number.

Parameters

nError

HID-specific error number.

Returns

Null-terminated error string.

Reimplemented from rnr::HIDInput.

Definition at line 791 of file HIDXbox360.h.

References calibrateJoySticks(), close(), open(), run(), setLED(), setRumble(), stop(), rnr::HIDInput::T_UPDATE_DFT, and update().

    {
      return nError < 0? libusb_error_name(nError): "Ok";
    }

void HIDXbox360::goad ( )

protected

Goad the Xbox360 to send a message.

Are you still linked?

Definition at line 420 of file HIDXbox360.cxx.

References rnr::HIDXbox360::UsbPkt_T::m_bHasSubmitted, rnr::HIDXbox360::UsbPkt_T::m_bufData, m_nLEDPattern, m_nProdId, m_usbPkt, rnr::HIDXbox360::UsbPkt_T::m_usbTransfer, UsbPktIdGoad, XBOX360_LED_MSG_LEN, XBOX360_LED_MSG_TYPE, XBOX360_LED_PAT_MASK, XBOX360_LED_PAT_POS, XBOX360_MSG_LEN_POS, XBOX360_MSG_TYPE_POS, XBOX360_WIRED_PROD_ID, XBOX360_WIRELESS_PROD_ID, XBOX360_WL_LED_MSG_LEN, XBOX360_WL_LED_PAT_1, XBOX360_WL_LED_PAT_2, XBOX360_WL_LED_PAT_3, XBOX360_WL_PKT_HDR_LEN, XBOX360_WL_PKT_TYPE_NORM, and XBOX360_WL_PKT_TYPE_POS.

{
  byte_t *p;
  size_t  n;
  int     rc;

  //
  // Request already pending.
  //
  if( m_usbPkt[UsbPktIdGoad].m_bHasSubmitted )
  {
    return;
  }

  //
  // Transfer is being canceled.
  //
  else if( m_usbPkt[UsbPktIdGoad].m_bCancel )
  {
    return;
  }

  p = m_usbPkt[UsbPktIdGoad].m_bufData;

  //
  // Use LED to prompt an Xbox360 response.
  //
  switch( m_nProdId )
  {
    case XBOX360_WIRELESS_PROD_ID:
    case XBOX360_WIRELESS_WIN_PROD_ID:
      n = XBOX360_WL_PKT_HDR_LEN + XBOX360_WL_LED_MSG_LEN;

      memset(p, 0, n);

      // header
      p[XBOX360_WL_PKT_TYPE_POS] = XBOX360_WL_PKT_TYPE_NORM;
      p[1] = XBOX360_WL_LED_PAT_1;
      p[2] = XBOX360_WL_LED_PAT_2;
      p[3] = XBOX360_WL_LED_PAT_3 | m_nLEDPattern;

      m_usbPkt[UsbPktIdGoad].m_usbTransfer->length = (int)n;
      break;

    case XBOX360_WIRED_PROD_ID:
    default:
      n = XBOX360_LED_MSG_LEN;

      p[XBOX360_MSG_TYPE_POS] = XBOX360_LED_MSG_TYPE;
      p[XBOX360_MSG_LEN_POS]  = (byte_t)n;
      p[XBOX360_LED_PAT_POS]  = (byte_t)m_nLEDPattern & XBOX360_LED_PAT_MASK;

      m_usbPkt[UsbPktIdGoad].m_usbTransfer->length = (int)n;
      break;
  }

  m_usbPkt[UsbPktIdGoad].m_bHasSubmitted = true;

  rc = libusb_submit_transfer(m_usbPkt[UsbPktIdGoad].m_usbTransfer);
 
  switch( rc )
  {
    case LIBUSB_SUCCESS:
      break;
    default:
      m_usbPkt[UsbPktIdGoad].m_bHasSubmitted = false;
      LOGERROR("Goad libusb_submit_transfer() failed: %s.",
        libusb_error_name(rc));
      break;
  }
}

int HIDXbox360::initTransferPkts ( )

protected

Allocate and initialize all USB transfer packets.

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Definition at line 933 of file HIDXbox360.cxx.

References rnr::HIDXbox360::UsbPkt_T::m_bCancel, rnr::HIDXbox360::UsbPkt_T::m_bHasSubmitted, rnr::HIDInput::m_nError, m_usbHandle, m_usbPkt, rnr::HIDXbox360::UsbPkt_T::m_usbTransfer, transferCallbackGoad(), transferCallbackInput(), transferCallbackLED(), transferCallbackRumble(), UsbPktIdGoad, UsbPktIdInput, UsbPktIdLED, UsbPktIdNumOf, UsbPktIdRumble, XBOX360_READ_ENDPOINT, and XBOX360_WRITE_ENDPOINT.

Referenced by open().

{
  for(int i=0; i<UsbPktIdNumOf; ++i)
  {
    // allocate a libusb transfer
    m_usbPkt[i].m_usbTransfer = libusb_alloc_transfer(0);

    if( m_usbPkt[i].m_usbTransfer == NULL )
    {
      LOGERROR("libusb_alloc_transfer() failed.");
      m_nError = LIBUSB_ERROR_OTHER;
      return m_nError;
    }

    //
    // Populate transfer fields.
    //
    switch( i )
    {
      case UsbPktIdInput:
        libusb_fill_interrupt_transfer(m_usbPkt[i].m_usbTransfer,
                                       m_usbHandle,
                                       XBOX360_READ_ENDPOINT, 
                                       m_usbPkt[i].m_bufData,
                                       (int)sizeof(m_usbPkt[i].m_bufData),
                                       transferCallbackInput,
                                       this,
                                       100); // timeout ms
        break;
      case UsbPktIdRumble:
        libusb_fill_interrupt_transfer(m_usbPkt[i].m_usbTransfer,
                                       m_usbHandle,
                                       XBOX360_WRITE_ENDPOINT, 
                                       m_usbPkt[i].m_bufData,
                                       (int)sizeof(m_usbPkt[i].m_bufData),
                                       transferCallbackRumble,
                                       this,
                                       0); // timeout ms
        break;
      case UsbPktIdLED:
        libusb_fill_interrupt_transfer(m_usbPkt[i].m_usbTransfer,
                                       m_usbHandle,
                                       XBOX360_WRITE_ENDPOINT, 
                                       m_usbPkt[i].m_bufData,
                                       (int)sizeof(m_usbPkt[i].m_bufData),
                                       transferCallbackLED,
                                       this,
                                       0); // timeout ms
        break;
      case UsbPktIdGoad:
        libusb_fill_interrupt_transfer(m_usbPkt[i].m_usbTransfer,
                                       m_usbHandle,
                                       XBOX360_WRITE_ENDPOINT, 
                                       m_usbPkt[i].m_bufData,
                                       (int)sizeof(m_usbPkt[i].m_bufData),
                                       transferCallbackGoad,
                                       this,
                                       0); // timeout ms
        break;
    }

    m_usbPkt[i].m_bHasSubmitted = false;
    m_usbPkt[i].m_bCancel       = false;
  }
}

bool rnr::HIDXbox360::isWireless ( )

inline

Check if Xbox360 hardware is wireless.

Returns

Returns true or false.

Definition at line 926 of file HIDXbox360.h.

References debugPrintHdr(), debugPrintState(), m_nProdId, and XBOX360_WIRELESS_PROD_ID.

Referenced by transferCallbackInput().

    {
      return  m_nProdId == XBOX360_WIRELESS_PROD_ID ||
              m_nProdId == XBOX360_WIRELESS_WIN_PROD_ID;
    }

void rnr::HIDXbox360::lock ( )

inlineprotected

Lock update thread.

The calling thread will block while waiting for the mutex to become available. Once locked, the update thread will block.

The lock()/unlock() primitives provide a safe mechanism to modify state.

Context:

Any.

Definition at line 1207 of file HIDXbox360.h.

Referenced by blockWait(), and update().

    {
      pthread_mutex_lock(&m_mutexUpdate);
    }

int HIDXbox360::open ( )

virtual

Open connection to an USB Xbox360 controller.

The first Xbox found will be opened. All intefaces will be bound to this class instance.

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Implements rnr::HIDInput.

Definition at line 159 of file HIDXbox360.cxx.

References clearErrorCnts(), close(), flushInput(), initTransferPkts(), rnr::HIDInput::m_bFatal, rnr::HIDInput::m_nError, m_nLEDPattern, m_nLeftRumble, m_nProdId, m_nRightRumble, m_strProdName, m_usbContext, m_usbHandle, openXbox(), rnr::HIDInput::setConnectionState(), setLinkState(), submitReadTransfer(), XBOX360_LED_PAT_ALL_BLINK, XBOX360_WIRED_PROD_ID, XBOX360_WIRELESS_PROD_ID, and zeroState().

Referenced by getStrError(), main(), testXboxInput(), testXboxLED(), testXboxRumble(), and testXboxSanity().

{
  // in fatal condition and/or libusb not initialzed
  if( m_bFatal || (m_usbContext == NULL) )
  {
    LOGERROR("libusb not initialized.");
  }

  // Xbox USB device alread open
  else if( m_usbHandle != NULL )
  {
    LOGERROR("Xbox360 controller 0x%04x already open.", m_nProdId);
    m_nError = LIBUSB_ERROR_IO;
  }

  // failed to open Xbox
  else if( (m_nError = openXbox()) < 0 )
  {
    LOGERROR("open() failed: %s.", libusb_error_name(m_nError));
  }

  // failed to allocate and initialize USB transfer packets
  else if( (m_nError = initTransferPkts()) < 0 )
  {
    LOGERROR("initTransferPkts() failed: %s.", libusb_error_name(m_nError));
    close();
  }

  // failed to start async read transfer
  else if( (m_nError = submitReadTransfer()) < 0 )
  {
    LOGERROR("submitReadTransfer() failed: %s.", libusb_error_name(m_nError));
    close();
  }

  // success
  else
  {
    clearErrorCnts();
    zeroState();

    m_nLEDPattern   = XBOX360_LED_PAT_ALL_BLINK;
    m_nLeftRumble   = 0;
    m_nRightRumble  = 0;

    setConnectionState(true);

    flushInput();

    switch( m_nProdId )
    {
      case XBOX360_WIRED_PROD_ID:
        m_strProdName = "Xbox360 Wired Controller";
        setLinkState(true);
        break;
      case XBOX360_WIRELESS_PROD_ID:
      case XBOX360_WIRELESS_WIN_PROD_ID:
        m_strProdName = "Xbox360 Wireless Controller";
        break;
      default:
        m_strProdName = "Xbox360 Controller";
        break;
    }

    LOGDIAG3("Opened %s (product id=0x%04x).",
        m_strProdName.c_str(), m_nProdId);
  }

  return m_nError;
}

int HIDXbox360::openXbox ( )

protected

Open Xbox360 connection.

Checks for all supported Xbox Controllers and opens the first for communication All interfaces are claimed.

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Definition at line 783 of file HIDXbox360.cxx.

References claimXboxInterfaces(), close(), rnr::HIDInput::m_nError, m_nOffset, m_nProdId, m_usbContext, m_usbHandle, MICROSOFT_VENDOR_ID, XBOX360_MSG_OFFSET_DFT, XBOX360_MSG_OFFSET_W, XBOX360_MSG_OFFSET_WL, XBOX360_NO_PROD_ID, XBOX360_TETHERED_PROD_ID, XBOX360_WIRED_PROD_ID, and XBOX360_WIRELESS_PROD_ID.

Referenced by open().

{
  // Xbox product id's in priority search order
  static ushort_t xbox_prod_id[] =
  {
    XBOX360_WIRED_PROD_ID,
    XBOX360_TETHERED_PROD_ID,
    XBOX360_WIRELESS_PROD_ID,
    XBOX360_WIRELESS_WIN_PROD_ID
  };

  size_t  i;
  int     rc;

  //
  // Find an Xbox360 controller and claim its interfaces.
  //
  for(i=0; i<arraysize(xbox_prod_id); ++i)
  {
    // open by vendor id, product id
    m_usbHandle = libusb_open_device_with_vid_pid(m_usbContext,
                                          MICROSOFT_VENDOR_ID,
                                          xbox_prod_id[i]);

    if( m_usbHandle != NULL )
    {
      m_nProdId = xbox_prod_id[i];

      if( (rc = claimXboxInterfaces()) < 0 )
      {
        close();
      }
      else
      {
        break;
      }
    }
  }

  //
  // Opened successfully
  //
  if( m_usbHandle != NULL )
  {
    // set specific Xbox360 product values
    switch( m_nProdId )
    {
      case XBOX360_WIRELESS_PROD_ID:
      case XBOX360_WIRELESS_WIN_PROD_ID:
        m_nOffset = XBOX360_MSG_OFFSET_WL;
        break;
      case XBOX360_WIRED_PROD_ID:
        m_nOffset = XBOX360_MSG_OFFSET_W;
        break;
      case XBOX360_TETHERED_PROD_ID:
      default:
        m_nOffset = XBOX360_MSG_OFFSET_DFT;
        break;
    }

    // reset the device to default state
    libusb_reset_device(m_usbHandle);

    return LIBUSB_SUCCESS;
  }

  //
  // Failure
  //
  else
  {
    m_nProdId = XBOX360_NO_PROD_ID;
    m_nError  = LIBUSB_ERROR_NO_DEVICE;
  }

  return m_nError;
}

bool HIDXbox360::parseWired ( byte_t  buf[], ssize_t  n  )

protected

Parse wired Xbox360 input events.

Parameters

buf	Raw USB input buffer.
n	Length of data in buffer.

Returns

Returns true if good parse, else false.

Definition at line 1543 of file HIDXbox360.cxx.

References updateButtonState(), updateLEDState(), XBOX360_BTTN_MSG_LEN, XBOX360_BTTN_MSG_TYPE, XBOX360_LED_MSG_LEN, XBOX360_LED_MSG_TYPE, XBOX360_MSG_LEN_POS, and XBOX360_MSG_TYPE_POS.

Referenced by transferCallbackInput().

{
  bool bGoodPkt;

  switch( buf[XBOX360_MSG_TYPE_POS] )
  {
    case XBOX360_BTTN_MSG_TYPE:
      if( buf[XBOX360_MSG_LEN_POS] == XBOX360_BTTN_MSG_LEN )
      {
        updateButtonState(buf, n);
        //LOGDIAG3("updated button state.");
        bGoodPkt = true;
      }
      break;
    case XBOX360_LED_MSG_TYPE:
      if( buf[XBOX360_MSG_LEN_POS] == XBOX360_LED_MSG_LEN )
      {
        updateLEDState(buf, n);
        //LOGDIAG3("updated led state.");
        bGoodPkt = true;
      }
      break;
    default:
      break;
  }

  if( !bGoodPkt )
  {
    //debugPrintTransferBuf("DBG: wired input", buf, n);
  }

  return bGoodPkt;
}

bool HIDXbox360::parseWireless ( byte_t  buf[], ssize_t  n  )

protected

Parse wireless Xbox360 input events.

While executing, the Xbox controller can be unplugged. For a wireless connection, the dongle - Xbox controller can become unpaired, out-of-range, or wonking connection.

Parameters

buf	Raw USB input buffer.
n	Length of data in buffer.

Returns

Returns true if good parse, else false.

Definition at line 1381 of file HIDXbox360.cxx.

References rnr::HIDInput::m_bIsLinked, m_nBatteryStatus, m_nErrorRcv, m_nErrorRcvTimeout, m_nErrorTotal, m_nOffset, m_nStatus, m_strSerialNum, setLinkState(), updateButtonState(), XBOX360_BTTN_MSG_TYPE, XBOX360_MSG_TYPE_POS, XBOX360_WL_ANN_BATT_POS, XBOX360_WL_ANN_PAT_1, XBOX360_WL_ANN_PAT_2, XBOX360_WL_ANN_PAT_3, XBOX360_WL_ANN_SN_LEN, XBOX360_WL_ANN_SN_POS, XBOX360_WL_BATT_BATT_POS, XBOX360_WL_BATT_PAT_1, XBOX360_WL_BATT_PAT_2, XBOX360_WL_BATT_PAT_3, XBOX360_WL_BTTN_PAT_1, XBOX360_WL_BTTN_PAT_2, XBOX360_WL_BTTN_PAT_3, XBOX360_WL_F8_PAT_1, XBOX360_WL_F8_PAT_3, XBOX360_WL_LINK_PKT_LEN, XBOX360_WL_LINK_STATUS_CTLR, XBOX360_WL_LINK_STATUS_CTLR_HEADSET, XBOX360_WL_LINK_STATUS_HEADSET, XBOX360_WL_LINK_STATUS_NO_LINK, XBOX360_WL_LINK_STATUS_POS, XBOX360_WL_NORM_PKT_LEN, XBOX360_WL_NULL_PAT_1, XBOX360_WL_NULL_PAT_2, XBOX360_WL_NULL_PAT_3_ACK, XBOX360_WL_PKT_TYPE_CHG, XBOX360_WL_PKT_TYPE_NORM, and XBOX360_WL_PKT_TYPE_POS.

Referenced by transferCallbackInput().

{
  bool  bGoodPkt    = true;   // recevied good (bad) packet
  bool  bNewState   = true;   // new link state

  //
  // Link Status Change Packet. Not reliable.
  //
  if( (n == XBOX360_WL_LINK_PKT_LEN) &&
      (buf[XBOX360_WL_PKT_TYPE_POS] == XBOX360_WL_PKT_TYPE_CHG) )
  {
    m_nStatus = buf[XBOX360_WL_LINK_STATUS_POS];
    switch( m_nStatus )
    {
      case XBOX360_WL_LINK_STATUS_CTLR:
        LOGDIAG3("Wireless status: Contoller linked.");
        break;
      case XBOX360_WL_LINK_STATUS_HEADSET:
        LOGDIAG3("Wireless status: Headset linked.");
        break;
      case XBOX360_WL_LINK_STATUS_CTLR_HEADSET:
        LOGDIAG3("Wireless status: Contoller and headset linked.");
        break;
      case XBOX360_WL_LINK_STATUS_NO_LINK:
        LOGERROR("Wireless link: No link.");
        bNewState = false;
        break;
      default:
        break;
    }
  }

  //
  // Packet is too short.
  //
  else if( n < XBOX360_WL_NORM_PKT_LEN )
  {
    LOGERROR("Short packet.");
    bGoodPkt  = false;
    bNewState = m_bIsLinked;
    //debugPrintTransferBuf("DBG: short pkt", buf, n);
  }

  //
  // Unknown packet type.
  //
  // Note: These could be valid packets, simply undocumented.
  //
  else if( buf[XBOX360_WL_PKT_TYPE_POS] != XBOX360_WL_PKT_TYPE_NORM )
  {
    LOGERROR("Unknown packet type = 0x%02x.", buf[XBOX360_WL_PKT_TYPE_POS]);
    bGoodPkt  = false;
    bNewState = m_bIsLinked;
    //debugPrintTransferBuf("DBG: unknown pkt type", buf, n);
  }

  //
  // Button state update message.
  //
  else if(  (buf[1] == XBOX360_WL_BTTN_PAT_1) &&
            (buf[2] == XBOX360_WL_BTTN_PAT_2) &&
            (buf[3] == XBOX360_WL_BTTN_PAT_3) &&
            (buf[m_nOffset+XBOX360_MSG_TYPE_POS] == XBOX360_BTTN_MSG_TYPE) )
  {
    LOGDIAG4("Button state update packet.");
    updateButtonState(buf+m_nOffset, n-m_nOffset);
  }

  //
  // Announcement message.
  // 
  // It is sent when controller transitions from no-link to linked. Not so
  // often sent by dongle though.
  //
  else if(  (buf[1] == XBOX360_WL_ANN_PAT_1) &&
            (buf[2] == XBOX360_WL_ANN_PAT_2) &&
            (buf[3] == XBOX360_WL_ANN_PAT_3) )
  {
    char        bufsn[16];
    const char *sep = "";

    m_strSerialNum.clear();

    for(int i=0; i<XBOX360_WL_ANN_SN_LEN; ++i)
    {
      sprintf(bufsn, "%s%02x", sep, (uint_t)buf[XBOX360_WL_ANN_SN_POS+i]&0xff);
      m_strSerialNum += bufsn;
      sep = ":";
    }

    m_nBatteryStatus = buf[XBOX360_WL_ANN_BATT_POS];

    LOGDIAG3("Announcement packet: S/N %s, battery status: %d",
          m_strSerialNum.c_str(), m_nBatteryStatus);
  }

  //
  // Battery status message.
  //
  else if(  (buf[1] == XBOX360_WL_BATT_PAT_1) &&
            (buf[2] == XBOX360_WL_BATT_PAT_2) &&
            (buf[3] == XBOX360_WL_BATT_PAT_3) )
  {
    m_nBatteryStatus = buf[XBOX360_WL_BATT_BATT_POS];
    LOGDIAG3("Battery status packet: battery status: %d", m_nBatteryStatus);
  }

  //
  // Null message.
  //
  else if(  (buf[1] == XBOX360_WL_NULL_PAT_1) &&
            (buf[2] == XBOX360_WL_NULL_PAT_2) )
  {
    LOGDIAG4("00 messsage: val=0x%02x.", buf[3]);
    if( buf[3] != XBOX360_WL_NULL_PAT_3_ACK )
    {
      bNewState = m_bIsLinked;
    }
    //debugPrintTransferBuf("00 msg:", buf, 4);
  }

  //
  // F8 message. Ignore.
  //
  else if(  (buf[1] == XBOX360_WL_F8_PAT_1) &&
            (buf[3] == XBOX360_WL_F8_PAT_3) )
  {
    LOGDIAG4("F8 messsage: val=0x%02x.", buf[2]);
    bNewState = m_bIsLinked;
    //debugPrintTransferBuf("F8 msg:", buf, 4);
  }

  //
  // Don't know, but assume valid. Ignore.
  //
  else
  {
    LOGDIAG4("%02x messsage: val=0x%02x.", buf[1]);
    bNewState = m_bIsLinked;
    //debugPrintTransferBuf("unknown msg:", buf, 4);
  }

  if( bGoodPkt )
  {
    m_nErrorRcv         = 0;
    m_nErrorRcvTimeout  = 0;
  }

  else
  {
    ++m_nErrorRcv;
    ++m_nErrorTotal;
  }

  if( bNewState != m_bIsLinked )
  {
    setLinkState(bNewState);
  }

  return bGoodPkt;
}

bool HIDXbox360::ping ( )

virtual

Ping device if it is connected and is responding.

Note

Ping does not work for wireless controllers unless link is up which kind of defeats the purpose of ping.

Ping is not reliable. Always return true.

Returns

Returns true if the HID is responding, else false.

Reimplemented from rnr::HIDInput.

Definition at line 414 of file HIDXbox360.cxx.

References rnr::HIDInput::m_bIsLinked.

Referenced by getCurrentState(), and testXboxSanity().

{
  // N.B. ping is unreliable - simply return link state
  return m_bIsLinked;
}

int HIDXbox360::run ( float  hz = 30.0 )

virtual

Create and run USB update in thread.

Parameters

hz	Update Hertz.

Returns

Returns 0 on success, < 0 on failure.

Definition at line 292 of file HIDXbox360.cxx.

References createUpdateThread(), m_eThreadState, m_tsThread, and ThreadStateNone.

Referenced by getStrError(), and main().

{
  if( hz <= 0.0 )
  {
    hz = 1.0;
  }

  float t = 1.0/hz;

  m_tsThread.tv_sec = (long)t;
  m_tsThread.tv_nsec = (long)(t - m_tsThread.tv_sec);

  if( m_eThreadState != ThreadStateNone )
  {
    LOGERROR("Update thread already running.");
    return -1;
  }

  else if( createUpdateThread() < 0 )
  {
    LOGERROR("Failed to create update thread.");
    return -1;
  }
 
  else
  {
    return 0;
  }
}

void rnr::HIDXbox360::setErrorThresholds ( int  nErrorRcvTimeoutTh = NErrorRcvTimeoutThDft, int  nErrorRcvTh = NErrorRcvThDft, int  nErrorTotalTh = NErrorTotalThDft  )

inline

Set error count thresholds.

Parameters

nErrorRcvTimeoutTh	Consecutive receive timeout error count threshold. Set to 0 to ignore.
nErrorRcvTh	Consecutive receive error count threshold. Set to 0 to ignore.
nErrorTotalTh	Total receive error count threshold. Set to 0 to ignore.

Definition at line 912 of file HIDXbox360.h.

References m_nErrorRcvTh, m_nErrorRcvTimeoutTh, and m_nErrorTotalTh.

Referenced by HIDXbox360(), and main().

    {
      m_nErrorRcvTimeoutTh  = nErrorRcvTimeoutTh;
      m_nErrorRcvTh         = nErrorRcvTh;
      m_nErrorTotalTh       = nErrorTotalTh;
    }

int HIDXbox360::setFeatureVal ( int  iMnem, int  nVal  )

virtual

Set the value associated with the mapped user mnemonic.

Parameters

	iMnem	User-specific mnemonic.
[in]	nVal	New input HID output value (e.g.LED). Meaning is specific to input.

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Implements rnr::HIDInput.

Definition at line 331 of file HIDXbox360.cxx.

References rnr::HIDInput::m_featMap, m_state, setLED(), setRumble(), rnr::Xbox360FeatIdLEDPat, rnr::Xbox360FeatIdLeftRumble, and rnr::Xbox360FeatIdRightRumble.

Referenced by getFeatureVal().

{
  FeatMap_T::iterator pos;

  if( (pos = m_featMap.find(iMnem)) == m_featMap.end() )
  {
    return LIBUSB_ERROR_INVALID_PARAM;
  }

  switch( pos->second )
  {
    case Xbox360FeatIdLeftRumble:
      return setRumble(nVal, m_state[Xbox360FeatIdRightRumble]);
    case Xbox360FeatIdRightRumble:
      return setRumble(m_state[Xbox360FeatIdLeftRumble], nVal);
    case Xbox360FeatIdLEDPat:
      return setLED(nVal);
    default:
      return LIBUSB_ERROR_INVALID_PARAM;
  }
}

int HIDXbox360::setLED

(

int

nPattern

)

Set the LED pattern.

Todo:

Does not work for wireless xbox controller yet.

Parameters

nPattern

LED pattern. See XBOX_LED_PAT_ALL_OFF ...

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Definition at line 623 of file HIDXbox360.cxx.

References rnr::HIDXbox360::UsbPkt_T::m_bHasSubmitted, rnr::HIDInput::m_bIsLinked, rnr::HIDXbox360::UsbPkt_T::m_bufData, rnr::HIDInput::m_nError, m_nErrorSend, m_nErrorTotal, m_nLEDPattern, m_nProdId, m_usbPkt, rnr::HIDXbox360::UsbPkt_T::m_usbTransfer, UsbPktIdLED, XBOX360_LED_MSG_LEN, XBOX360_LED_MSG_TYPE, XBOX360_LED_PAT_MASK, XBOX360_LED_PAT_POS, XBOX360_MSG_LEN_POS, XBOX360_MSG_TYPE_POS, XBOX360_WIRED_PROD_ID, XBOX360_WIRELESS_PROD_ID, XBOX360_WL_LED_MSG_LEN, XBOX360_WL_LED_PAT_1, XBOX360_WL_LED_PAT_2, XBOX360_WL_LED_PAT_3, XBOX360_WL_PKT_HDR_LEN, XBOX360_WL_PKT_TYPE_NORM, and XBOX360_WL_PKT_TYPE_POS.

Referenced by getStrError(), main(), setFeatureVal(), setLinkState(), and testXboxLED().

{
  byte_t *p;
  size_t  n;
  int     nMaxTries = 3;
  int     nTries;
  int     rc;

  // target
  m_nLEDPattern = nPattern & XBOX360_LED_PAT_MASK;

  //
  // No link.
  //
  if( !m_bIsLinked )
  {
    return LIBUSB_SUCCESS;
  }

  //
  // Transfer is being canceled.
  //
  else if( m_usbPkt[UsbPktIdLED].m_bCancel )
  {
    return LIBUSB_SUCCESS;
  }

  LOGDIAG4("Set LED pattern %d.", m_nLEDPattern);

  //
  // Previous event to LED state change is pending.
  //
  for(nTries=0, rc=LIBUSB_ERROR_BUSY;
      (nTries<nMaxTries) && (rc==LIBUSB_ERROR_BUSY);
      ++nTries)
  {
    if( m_usbPkt[UsbPktIdLED].m_bHasSubmitted )
    {
      usleep(10);
    }
    else
    {
      rc = LIBUSB_SUCCESS;
    }
  }


  //
  // Last request failed. It may have been lost. Fail this request, but
  // reset to re-enable.
  //
  if( rc != LIBUSB_SUCCESS )
  {
    LOGERROR("LED libusb_submit_transfer() failed in %d tries: %s.",
          nTries, libusb_error_name(rc));
    m_usbPkt[UsbPktIdLED].m_bHasSubmitted = false;
    m_nErrorSend++;
    m_nErrorTotal++;
    m_nError = rc;
    return rc;
  }


  //
  // Write new LED pattern request.
  //
  p = m_usbPkt[UsbPktIdLED].m_bufData;

  switch( m_nProdId )
  {
    case XBOX360_WIRELESS_PROD_ID:
    case XBOX360_WIRELESS_WIN_PROD_ID:
      n = XBOX360_WL_PKT_HDR_LEN + XBOX360_WL_LED_MSG_LEN;

      memset(p, 0, n);

      // header
      p[XBOX360_WL_PKT_TYPE_POS] = XBOX360_WL_PKT_TYPE_NORM;
      p[1] = XBOX360_WL_LED_PAT_1;
      p[2] = XBOX360_WL_LED_PAT_2;
      p[3] = XBOX360_WL_LED_PAT_3 | m_nLEDPattern;

      m_usbPkt[UsbPktIdLED].m_usbTransfer->length = (int)n;
      break;

    case XBOX360_WIRED_PROD_ID:
    default:
      n = XBOX360_LED_MSG_LEN;

      p[XBOX360_MSG_TYPE_POS] = XBOX360_LED_MSG_TYPE;
      p[XBOX360_MSG_LEN_POS]  = (byte_t)n;
      p[XBOX360_LED_PAT_POS]  = (byte_t)m_nLEDPattern & XBOX360_LED_PAT_MASK;

      m_usbPkt[UsbPktIdLED].m_usbTransfer->length = (int)n;
      break;
  }

  m_usbPkt[UsbPktIdLED].m_bHasSubmitted = true;

  rc = libusb_submit_transfer(m_usbPkt[UsbPktIdLED].m_usbTransfer);
 
  switch( rc )
  {
    case LIBUSB_SUCCESS:
      break;
    default:
      LOGERROR("LED libusb_submit_transfer() failed: %s.",
        libusb_error_name(rc));
      m_usbPkt[UsbPktIdLED].m_bHasSubmitted = false;
      m_nErrorSend++;
      m_nErrorTotal++;
      m_nError = rc;
      break;
  }

  return rc;
}

void HIDXbox360::setLinkState ( bool  bNewState )

protectedvirtual

Set new link state.

Parameters

bNewState

New link state.

Reimplemented from rnr::HIDInput.

Definition at line 759 of file HIDXbox360.cxx.

References rnr::HIDInput::m_bIsLinked, m_nLEDPattern, setLED(), rnr::HIDInput::setLinkState(), and zeroState().

Referenced by checkErrorThresholds(), close(), open(), parseWireless(), transferCallbackInput(), transferCallbackLED(), and transferCallbackRumble().

{
  bool bOldState = m_bIsLinked;

  HIDInput::setLinkState(bNewState);

  //
  // Transition from not linked to linked.
  //
  if( !bOldState && bNewState )
  {
    // reset LED pattern since the xbox may have gone to a 'not linked' pattern
    setLED(m_nLEDPattern);
  }

  //
  // Transition from linked to not linked.
  //
  else if( bOldState && !bNewState )
  {
    zeroState();
  }
}

int HIDXbox360::setRumble	(	int	nLeftMot,
		int	nRightMot
	)

Set the rumble instensity.

Note

The left motor only really works above 255.

The right motor only really works below 256.

Todo:

Does not work for wireless xbox controller yet.

Parameters

nLeftMot	Left, low-frequency motor [0-255].
nRightMot	Right, high-frequency motor [0-255].

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Definition at line 492 of file HIDXbox360.cxx.

References rnr::HIDXbox360::UsbPkt_T::m_bHasSubmitted, rnr::HIDInput::m_bIsLinked, rnr::HIDXbox360::UsbPkt_T::m_bufData, rnr::HIDInput::m_nError, m_nErrorSend, m_nErrorTotal, m_nLeftRumble, m_nProdId, m_nRightRumble, m_usbPkt, rnr::HIDXbox360::UsbPkt_T::m_usbTransfer, UsbPktIdRumble, XBOX360_MSG_LEN_POS, XBOX360_MSG_TYPE_POS, XBOX360_RUMBLE_LEFT_MASK, XBOX360_RUMBLE_LEFT_POS, XBOX360_RUMBLE_MSG_LEN, XBOX360_RUMBLE_MSG_TYPE, XBOX360_RUMBLE_RIGHT_MASK, XBOX360_RUMBLE_RIGHT_POS, XBOX360_WIRED_PROD_ID, XBOX360_WIRELESS_PROD_ID, XBOX360_WL_PKT_HDR_LEN, XBOX360_WL_PKT_TYPE_NORM, XBOX360_WL_PKT_TYPE_POS, XBOX360_WL_RUMBLE_PAT_1, XBOX360_WL_RUMBLE_PAT_2, and XBOX360_WL_RUMBLE_PAT_3.

Referenced by getStrError(), main(), setFeatureVal(), and testXboxRumble().

{
  byte_t *p;
  size_t  n;
  int     nMaxTries = 3;
  int     nTries;
  int     rc;

  // targets
  m_nLeftRumble   = nLeftMot & XBOX360_RUMBLE_LEFT_MASK;
  m_nRightRumble  = nRightMot & XBOX360_RUMBLE_RIGHT_MASK;

  //
  // No link.
  //
  if( !m_bIsLinked )
  {
    return LIBUSB_SUCCESS;
  }

  //
  // Transfer is being canceled.
  //
  else if( m_usbPkt[UsbPktIdRumble].m_bCancel )
  {
    return LIBUSB_SUCCESS;
  }

  LOGDIAG4("Set rumble moters %d, %d.", m_nLeftRumble, m_nRightRumble);

  //
  // Previous event to rumble change is pending.
  //
  for(nTries=0, rc=LIBUSB_ERROR_BUSY;
      (nTries<nMaxTries) && (rc==LIBUSB_ERROR_BUSY);
      ++nTries)
  {
    if( m_usbPkt[UsbPktIdRumble].m_bHasSubmitted )
    {
      usleep(10);
    }
    else
    {
      rc = LIBUSB_SUCCESS;
    }
  }

  //
  // Last request failed. It may have been lost. Fail this request, but
  // reset to re-enable.
  //
  if( rc != LIBUSB_SUCCESS )
  {
    LOGERROR("Rumble libusb_submit_transfer() failed in %d tries: %s.",
          nTries, libusb_error_name(rc));
    m_usbPkt[UsbPktIdRumble].m_bHasSubmitted = false;
    m_nErrorSend++;
    m_nErrorTotal++;
    m_nError = rc;
    return rc;
  }

  //
  // Write new rumble request.
  //
  p = m_usbPkt[UsbPktIdRumble].m_bufData;

  switch( m_nProdId )
  {
    //
    // From xboxdrv-linux-0.8.5, rumble command =
    // 0x00, 0x01, 0x0f, 0xc0, 0x00, left, right, 0x00, 0x00, 0x00, 0x00, 0x00
    //
    case XBOX360_WIRELESS_PROD_ID:
    case XBOX360_WIRELESS_WIN_PROD_ID:
      n = XBOX360_WL_PKT_HDR_LEN + XBOX360_RUMBLE_MSG_LEN;

      memset(p, 0, n);

      // header
      p[XBOX360_WL_PKT_TYPE_POS] = XBOX360_WL_PKT_TYPE_NORM;
      p[1] = XBOX360_WL_RUMBLE_PAT_1;
      p[2] = XBOX360_WL_RUMBLE_PAT_2;
      p[3] = XBOX360_WL_RUMBLE_PAT_3;

      
      // message
      p[4] = XBOX360_RUMBLE_MSG_TYPE;
      p[5] = (byte_t)m_nLeftRumble;
      p[6] = (byte_t)m_nRightRumble;

      m_usbPkt[UsbPktIdRumble].m_usbTransfer->length = (int)n;
      break;

    case XBOX360_WIRED_PROD_ID:
    default:
      n = XBOX360_RUMBLE_MSG_LEN;

      memset(p, 0, n);

      // message
      p[XBOX360_MSG_TYPE_POS]     = XBOX360_RUMBLE_MSG_TYPE;
      p[XBOX360_MSG_LEN_POS]      = (byte_t)n;
      p[XBOX360_RUMBLE_LEFT_POS]  = (byte_t)nLeftMot;
      p[XBOX360_RUMBLE_RIGHT_POS] = (byte_t)nRightMot;

      m_usbPkt[UsbPktIdRumble].m_usbTransfer->length = (int)n;
      break;
  }

  m_usbPkt[UsbPktIdRumble].m_bHasSubmitted = true;

  rc = libusb_submit_transfer(m_usbPkt[UsbPktIdRumble].m_usbTransfer);
 
  switch( rc )
  {
    case LIBUSB_SUCCESS:
      break;
    default:
      LOGERROR("Rumble libusb_submit_transfer() failed: %s.",
                libusb_error_name(rc));
      m_usbPkt[UsbPktIdRumble].m_bHasSubmitted = false;
      m_nErrorSend++;
      m_nErrorTotal++;
      m_nError = rc;
      break;
  }

  return rc;
}

void HIDXbox360::signalUpdateThread ( )

protected

Signal update thread of change of state.

Context:

Calling thread or Update thread.

Definition at line 1855 of file HIDXbox360.cxx.

References m_condUpdate.

Referenced by cancelUpdateThread(), and unlock().

{
  pthread_cond_signal(&m_condUpdate);
}

int HIDXbox360::stop ( )

virtual

Stop and destroy USB update thread.

Returns

Returns 0 on success, < 0 on failure.

Definition at line 322 of file HIDXbox360.cxx.

References cancelUpdateThread(), m_eThreadState, ThreadStateNone, and unlock().

Referenced by close(), and getStrError().

{
  cancelUpdateThread();
  unlock();
  m_eThreadState = ThreadStateNone;

  return 0;
}

int HIDXbox360::submitReadTransfer ( )

protected

Submit read Xbox input asynchronous transfer.

On error, the appropriate < 0 negated MIRE.MIRECore error code is returned.

Returns

On success, USBLIB_SUCCESS(0) is returned.
On error, the appropriate < 0 USBLIB_ERROR_* code is returned.

Definition at line 1019 of file HIDXbox360.cxx.

References rnr::HIDXbox360::UsbPkt_T::m_bHasSubmitted, rnr::HIDInput::m_nError, m_usbPkt, and UsbPktIdInput.

Referenced by open(), and transferCallbackInput().

{
  int   rc;

  m_usbPkt[UsbPktIdInput].m_bHasSubmitted = false;
  
  if( m_usbPkt[UsbPktIdInput].m_bCancel )
  {
    return LIBUSB_SUCCESS;
  }

  // set up transfer
  rc = libusb_submit_transfer(m_usbPkt[UsbPktIdInput].m_usbTransfer);

  if( rc == LIBUSB_SUCCESS )
  {
    m_usbPkt[UsbPktIdInput].m_bHasSubmitted = true;
  }
  else
  {
    LOGERROR("Input libusb_submit_transfer() failed: %s.",
        libusb_error_name(rc));
    m_nError = rc;
  }

  return rc;
}

void HIDXbox360::transferCallbackGoad ( struct libusb_transfer *  transfer )

staticprotected

Write packet to force a response packet from the Xbox360.

Note that the response is captured in the input transfer.

Parameters

transfer

USB transfer block structure.

Definition at line 1315 of file HIDXbox360.cxx.

References rnr::HIDXbox360::UsbPkt_T::m_bHasSubmitted, m_usbPkt, and UsbPktIdGoad.

Referenced by initTransferPkts().

{
  HIDXbox360 *pThis = (HIDXbox360*)transfer->user_data;

  pThis->m_usbPkt[UsbPktIdGoad].m_bHasSubmitted = false;

  //
  // USB transfer status. Not too concern about the status.
  //
  switch( transfer->status )
  {
    case LIBUSB_TRANSFER_COMPLETED:
      //pThis->debugPrintTransferBuf("DBG: goad cb", transfer);
      break;
    case LIBUSB_TRANSFER_NO_DEVICE:
    case LIBUSB_TRANSFER_TIMED_OUT:
    case LIBUSB_TRANSFER_CANCELLED:
    case LIBUSB_TRANSFER_ERROR:
    case LIBUSB_TRANSFER_STALL:
    case LIBUSB_TRANSFER_OVERFLOW:
    default:
      break;
  }
}

void HIDXbox360::transferCallbackInput ( struct libusb_transfer *  transfer )

staticprotected

Input transfer function callback.

Parameters

transfer

USB transfer block structure.

Definition at line 1047 of file HIDXbox360.cxx.

References checkErrorThresholds(), isWireless(), rnr::HIDXbox360::UsbPkt_T::m_bHasSubmitted, rnr::HIDInput::m_bIsLinked, m_nErrorRcv, m_nErrorRcvTimeout, m_nErrorTotal, m_nProdId, m_usbPkt, parseWired(), parseWireless(), rnr::HIDInput::setConnectionState(), setLinkState(), submitReadTransfer(), UsbPktIdInput, XBOX360_WIRED_PROD_ID, and XBOX360_WIRELESS_PROD_ID.

Referenced by initTransferPkts().

{
  HIDXbox360 *pThis = (HIDXbox360*)transfer->user_data;
  bool        bResubmit = true;
  bool        bReceived = false;

  //
  // USB transfer status.
  //
  switch( transfer->status )
  {
    //
    // Read transfer completed. Parse, validate, and set state according to the
    // received packet.
    //
    case LIBUSB_TRANSFER_COMPLETED:
      switch( pThis->m_nProdId )
      {
        case XBOX360_WIRELESS_PROD_ID:
        case XBOX360_WIRELESS_WIN_PROD_ID:
          bReceived = pThis->parseWireless(transfer->buffer,
                                          transfer->actual_length);
          break;
        case XBOX360_WIRED_PROD_ID:
        default:
          bReceived = pThis->parseWired(transfer->buffer,
                                       transfer->actual_length);
          break;
      }
      break;

    //
    // USB transfer error.
    //
    case LIBUSB_TRANSFER_ERROR:
      LOGERROR("Transfer error.");
      pThis->m_nErrorRcv++;
      pThis->m_nErrorTotal++;
      break;

    //
    // No USB device. Probably unplugged.
    //
    case LIBUSB_TRANSFER_NO_DEVICE:
      LOGERROR("Disconnected!");
      pThis->m_nErrorRcv++;
      pThis->m_nErrorTotal++;
      pThis->setConnectionState(false);
      pThis->setLinkState(false);
      bResubmit = false;
      break;

    //
    // USB transfer timed out. This will happen when there are no new Xbox
    // events to report or when there is no link for the wireless Xbox.
    // Critical to differentiate these two conditions.
    //
    case LIBUSB_TRANSFER_TIMED_OUT:
      //LOGERROR("Receive Timeout!");
      if( pThis->isWireless() && pThis->m_bIsLinked )
      {
        pThis->m_nErrorRcvTimeout++;
        if( (pThis->m_nErrorRcvTimeout % 15) == 0 ) // too quiet - goad xbox
        {
          // RDK can't get this to work
          //pThis->goad();
        }
      }
      break;

    //
    // USB transfer is being canceled. Typical when closing the interface.
    //
    case LIBUSB_TRANSFER_CANCELLED:
      LOGDIAG3("Tranfer cancelled.");
      bResubmit = false;
      break;

    //
    // USB transfer stalled.
    //
    case LIBUSB_TRANSFER_STALL:
      LOGERROR("Transfer stalled.");
      pThis->m_nErrorRcv++;
      pThis->m_nErrorTotal++;
      break;

    //
    // USB transfer overflow. Typically the OS cannot handle the events soon
    // enough.
    //
    case LIBUSB_TRANSFER_OVERFLOW:
      LOGERROR("Overflow: Amount transferred: %d", transfer->actual_length);
      pThis->m_nErrorRcv++;
      pThis->m_nErrorTotal++;
      break;

    //
    // Should never be here.
    //
    default:
      LOGERROR("HIDXbox360 Controller: Unknown error, USB status: %d", 
               transfer->status);
      pThis->m_nErrorRcv++;
      pThis->m_nErrorTotal++;
      break; 
  }

  //
  // Received an input packet.
  //
  if( bReceived )
  {
    pThis->m_nErrorRcv         = 0;
    pThis->m_nErrorRcvTimeout  = 0;
  }

  //
  // No input packet received. Check error thresholds, which could result in
  // taking down the link.
  //
  else
  {
    pThis->checkErrorThresholds();
  }

  //
  // Resubmit new read transfer request.
  //
  if( bResubmit )
  {
    pThis->submitReadTransfer();
  }

  //
  // Don't resubmit new read transfer request.
  //
  else
  {
    pThis->m_usbPkt[UsbPktIdInput].m_bHasSubmitted = false;
  }
}

void HIDXbox360::transferCallbackLED ( struct libusb_transfer *  transfer )

staticprotected

Write LED pattern transfer function callback.

Parameters

transfer

USB transfer block structure.

Definition at line 1253 of file HIDXbox360.cxx.

References rnr::HIDXbox360::UsbPkt_T::m_bHasSubmitted, m_nErrorRcv, m_nErrorRcvTimeout, m_nErrorSend, m_nErrorTotal, m_nLEDPattern, m_state, m_usbPkt, rnr::HIDInput::setConnectionState(), setLinkState(), UsbPktIdLED, and rnr::Xbox360FeatIdLEDPat.

Referenced by initTransferPkts().

{
  HIDXbox360 *pThis = (HIDXbox360*)transfer->user_data;

  pThis->m_usbPkt[UsbPktIdLED].m_bHasSubmitted = false;

  //
  // USB transfer status.
  //
  switch( transfer->status )
  {
    //
    // Write transfer completed. The buffer just contains the data sent in the
    // write tranfer buffer. Not a true reply, but accept as successful.
    // 
    case LIBUSB_TRANSFER_COMPLETED:
      pThis->m_state[Xbox360FeatIdLEDPat] = pThis->m_nLEDPattern;
      pThis->m_nErrorSend = 0;
      //pThis->debugPrintTransferBuf("DBG: led cb", transfer);
      break;

    //
    // No USB device. Probably unplugged.
    //
    case LIBUSB_TRANSFER_NO_DEVICE:
      LOGERROR("Disconnected!");
      pThis->m_nErrorSend++;
      pThis->m_nErrorTotal++;
      pThis->setConnectionState(false);
      pThis->setLinkState(false);
      break;

    //
    // USB transfer is being canceled. Typical when closing the interface.
    //
    case LIBUSB_TRANSFER_CANCELLED:
      LOGDIAG3("Tranfer cancelled.");
      break;

    //
    // USB transfer timed out. Write did not succeed in this case.
    //
    case LIBUSB_TRANSFER_TIMED_OUT:
      LOGERROR("USB write LED pattern timed out.");
      pThis->m_nErrorRcvTimeout++;
      break;

    //
    // USB transfer errors.
    //
    case LIBUSB_TRANSFER_ERROR:
    case LIBUSB_TRANSFER_STALL:
    case LIBUSB_TRANSFER_OVERFLOW:
    default:
      LOGERROR("USB write LED pattern (length=%d): USB status=%d.",
        transfer->length, transfer->status);
      pThis->m_nErrorRcv++;
      pThis->m_nErrorTotal++;
      break;
  }
}

void HIDXbox360::transferCallbackRumble ( struct libusb_transfer *  transfer )

staticprotected

Write rumble motor values transfer function callback.

Parameters

transfer

USB transfer block structure.

Definition at line 1190 of file HIDXbox360.cxx.

References rnr::HIDXbox360::UsbPkt_T::m_bHasSubmitted, m_nErrorRcv, m_nErrorRcvTimeout, m_nErrorSend, m_nErrorTotal, m_nLeftRumble, m_nRightRumble, m_state, m_usbPkt, rnr::HIDInput::setConnectionState(), setLinkState(), UsbPktIdRumble, rnr::Xbox360FeatIdLeftRumble, and rnr::Xbox360FeatIdRightRumble.

Referenced by initTransferPkts().

{
  HIDXbox360 *pThis = (HIDXbox360*)transfer->user_data;

  pThis->m_usbPkt[UsbPktIdRumble].m_bHasSubmitted = false;

  //
  // USB transfer status.
  //
  switch( transfer->status )
  {
    //
    // Write transfer completed. The buffer just contains the data sent in the
    // write tranfer buffer. Not a true reply, but accept as successful.
    // 
    case LIBUSB_TRANSFER_COMPLETED:
      pThis->m_state[Xbox360FeatIdLeftRumble]  = pThis->m_nLeftRumble;
      pThis->m_state[Xbox360FeatIdRightRumble] = pThis->m_nRightRumble;
      pThis->m_nErrorSend = 0;
      //pThis->debugPrintTransferBuf("DBG: rumble cb", transfer);
      break;

    //
    // No USB device. Probably unplugged.
    //
    case LIBUSB_TRANSFER_NO_DEVICE:
      LOGERROR("Disconnected!");
      pThis->m_nErrorSend++;
      pThis->m_nErrorTotal++;
      pThis->setConnectionState(false);
      pThis->setLinkState(false);
      break;

    //
    // USB transfer is being canceled. Typical when closing the interface.
    //
    case LIBUSB_TRANSFER_CANCELLED:
      LOGDIAG3("Tranfer cancelled.");
      break;

    //
    // USB transfer timed out. Write did not succeed in this case.
    //
    case LIBUSB_TRANSFER_TIMED_OUT:
      LOGERROR("USB write rumble motors timed out.");
      pThis->m_nErrorRcvTimeout++;
      break;

    //
    // USB transfer errors.
    //
    case LIBUSB_TRANSFER_ERROR:
    case LIBUSB_TRANSFER_STALL:
    case LIBUSB_TRANSFER_OVERFLOW:
    default:
      LOGERROR("USB write rumble motors failed (length=%d): USB status=%d",
        transfer->length, transfer->status);
      pThis->m_nErrorRcv++;
      pThis->m_nErrorTotal++;
      break;
  }
}

void rnr::HIDXbox360::unlock ( )

inlineprotected

Unlock the update thread.

The update() will be available to execute.

Context:

Any.

Definition at line 1220 of file HIDXbox360.h.

References blockWait(), signalUpdateThread(), and updateThread().

Referenced by blockWait(), stop(), and update().

    {
      pthread_mutex_unlock(&m_mutexUpdate);
    }

int HIDXbox360::update ( uint_t  uMSec = T_UPDATE_DFT )

virtual

Read device and update HID state.

Note

The application must call this function at regular intervals to insure that the USB stream does not stall.

Parameters

uMSec

Block wait at most the given milliseconds for events. If zero, then update() will handle any already-pending events and then immediately return (non-blocking). Otherwise, if no events are currently pending, update() will block waiting for events for up to the specified timeout. If an event arrives update() will return early.

Returns

On success, OK(0) is returned.
On error, RC_ERROR(-1) is returned.

Implements rnr::HIDInput.

Definition at line 1867 of file HIDXbox360.cxx.

References lock(), rnr::HIDInput::m_bIsConnected, rnr::HIDInput::m_nError, m_usbContext, and unlock().

Referenced by cancelTransfers(), flushInput(), getStrError(), testXboxInput(), testXboxLED(), testXboxRumble(), and updateThread().

{
  struct timeval  tvWait;

  // no connected
  if( !m_bIsConnected )
  {
    m_nError = LIBUSB_ERROR_NO_DEVICE;
    return m_nError;
  }

  tvWait.tv_sec   = 0;
  tvWait.tv_usec  = uMSec * 1000;

  lock();

  //
  // N.B. Cannot make libusb_handle_events_*() call from a callback since the
  // callback was called within this call. Causes deadlock.
  //
  m_nError = libusb_handle_events_timeout_completed(m_usbContext,
                                                      &tvWait, NULL);

  unlock();
 
  return m_nError;
}

void HIDXbox360::updateButtonState ( byte_t  msg[], ssize_t  n  )

protected

Update the controller input button state.

Parameters

msg	Message containing raw controller state data.
n	Length of data in message.

Definition at line 1577 of file HIDXbox360.cxx.

References convertToInt(), m_fLeftJoyB, m_fLeftJoyM, m_fRightJoyB, m_fRightJoyM, m_nLeftJoyDeadZone, m_nRightJoyDeadZone, m_state, updown(), XBOX360_BTTN_A_BUTTON_MASK, XBOX360_BTTN_A_BUTTON_POS, XBOX360_BTTN_B_BUTTON_MASK, XBOX360_BTTN_B_BUTTON_POS, XBOX360_BTTN_BACK_MASK, XBOX360_BTTN_BACK_POS, XBOX360_BTTN_CENTER_X_MASK, XBOX360_BTTN_CENTER_X_POS, XBOX360_BTTN_LEFT_BUMP_MASK, XBOX360_BTTN_LEFT_BUMP_POS, XBOX360_BTTN_LEFT_STICK_CLICK_MASK, XBOX360_BTTN_LEFT_STICK_CLICK_POS, XBOX360_BTTN_LEFT_TRIGGER_POS, XBOX360_BTTN_LEFT_X_POS_H, XBOX360_BTTN_LEFT_X_POS_L, XBOX360_BTTN_LEFT_Y_POS_H, XBOX360_BTTN_LEFT_Y_POS_L, XBOX360_BTTN_PAD_DOWN_MASK, XBOX360_BTTN_PAD_DOWN_POS, XBOX360_BTTN_PAD_LEFT_MASK, XBOX360_BTTN_PAD_LEFT_POS, XBOX360_BTTN_PAD_RIGHT_MASK, XBOX360_BTTN_PAD_RIGHT_POS, XBOX360_BTTN_PAD_UP_MASK, XBOX360_BTTN_PAD_UP_POS, XBOX360_BTTN_RIGHT_BUMP_MASK, XBOX360_BTTN_RIGHT_BUMP_POS, XBOX360_BTTN_RIGHT_STICK_CLICK_MASK, XBOX360_BTTN_RIGHT_STICK_CLICK_POS, XBOX360_BTTN_RIGHT_TRIGGER_POS, XBOX360_BTTN_RIGHT_X_POS_H, XBOX360_BTTN_RIGHT_X_POS_L, XBOX360_BTTN_RIGHT_Y_POS_H, XBOX360_BTTN_RIGHT_Y_POS_L, XBOX360_BTTN_START_MASK, XBOX360_BTTN_START_POS, XBOX360_BTTN_X_BUTTON_MASK, XBOX360_BTTN_X_BUTTON_POS, XBOX360_BTTN_Y_BUTTON_MASK, XBOX360_BTTN_Y_BUTTON_POS, XBOX360_MSG_LEN_POS, rnr::Xbox360FeatIdAButton, rnr::Xbox360FeatIdBack, rnr::Xbox360FeatIdBButton, rnr::Xbox360FeatIdCenterX, rnr::Xbox360FeatIdLeftBump, rnr::Xbox360FeatIdLeftJoyX, rnr::Xbox360FeatIdLeftJoyY, rnr::Xbox360FeatIdLeftStickClick, rnr::Xbox360FeatIdLeftTrigger, rnr::Xbox360FeatIdPadDown, rnr::Xbox360FeatIdPadLeft, rnr::Xbox360FeatIdPadRight, rnr::Xbox360FeatIdPadUp, rnr::Xbox360FeatIdRightBump, rnr::Xbox360FeatIdRightJoyX, rnr::Xbox360FeatIdRightJoyY, rnr::Xbox360FeatIdRightStickClick, rnr::Xbox360FeatIdRightTrigger, rnr::Xbox360FeatIdStart, rnr::Xbox360FeatIdXButton, and rnr::Xbox360FeatIdYButton.

Referenced by parseWired(), and parseWireless().

{
  int   val;

  // 19 or 20 byte message
  if( msg[XBOX360_MSG_LEN_POS] < XBOX360_BTTN_MSG_MIN_LEN )
  {
    return;
  }

  // --
  // Update state
  // --
  
  // 
  // D Pad
  //
  m_state[Xbox360FeatIdPadUp] =
        updown(msg[XBOX360_BTTN_PAD_UP_POS] & XBOX360_BTTN_PAD_UP_MASK);
  m_state[Xbox360FeatIdPadDown] =
        updown(msg[XBOX360_BTTN_PAD_DOWN_POS] & XBOX360_BTTN_PAD_DOWN_MASK);
  m_state[Xbox360FeatIdPadLeft] =
        updown(msg[XBOX360_BTTN_PAD_LEFT_POS] & XBOX360_BTTN_PAD_LEFT_MASK);
  m_state[Xbox360FeatIdPadRight] =
        updown(msg[XBOX360_BTTN_PAD_RIGHT_POS] & XBOX360_BTTN_PAD_RIGHT_MASK);

  //
  // Start/Back buttons
  //
  m_state[Xbox360FeatIdStart] =
        updown(msg[XBOX360_BTTN_START_POS] & XBOX360_BTTN_START_MASK);
  m_state[Xbox360FeatIdBack] =
        updown(msg[XBOX360_BTTN_BACK_POS] & XBOX360_BTTN_BACK_MASK);

  //
  // Stick clicks
  //
  m_state[Xbox360FeatIdLeftStickClick] =
    updown(msg[XBOX360_BTTN_LEFT_STICK_CLICK_POS] &
        XBOX360_BTTN_LEFT_STICK_CLICK_MASK);
  m_state[Xbox360FeatIdRightStickClick] =
    updown(msg[XBOX360_BTTN_RIGHT_STICK_CLICK_POS] &
        XBOX360_BTTN_RIGHT_STICK_CLICK_MASK);

  //
  // Bump buttons
  //
  m_state[Xbox360FeatIdLeftBump] =
      updown(msg[XBOX360_BTTN_LEFT_BUMP_POS] & XBOX360_BTTN_LEFT_BUMP_MASK);
  m_state[Xbox360FeatIdRightBump] =
      updown(msg[XBOX360_BTTN_RIGHT_BUMP_POS] & XBOX360_BTTN_RIGHT_BUMP_MASK);

  //
  // Center LED button
  //
  m_state[Xbox360FeatIdCenterX] =
        updown(msg[XBOX360_BTTN_CENTER_X_POS] & XBOX360_BTTN_CENTER_X_MASK);

  //
  // Function buttons
  //
  m_state[Xbox360FeatIdAButton] =
        updown(msg[XBOX360_BTTN_A_BUTTON_POS] & XBOX360_BTTN_A_BUTTON_MASK);
  m_state[Xbox360FeatIdBButton] =
        updown(msg[XBOX360_BTTN_B_BUTTON_POS] & XBOX360_BTTN_B_BUTTON_MASK);
  m_state[Xbox360FeatIdXButton] =
        updown(msg[XBOX360_BTTN_X_BUTTON_POS] & XBOX360_BTTN_X_BUTTON_MASK);
  m_state[Xbox360FeatIdYButton] =
        updown(msg[XBOX360_BTTN_Y_BUTTON_POS] & XBOX360_BTTN_Y_BUTTON_MASK);

  //
  // Triggers
  //
  m_state[Xbox360FeatIdLeftTrigger] =
            convertToInt(msg[XBOX360_BTTN_LEFT_TRIGGER_POS], 0);
  m_state[Xbox360FeatIdRightTrigger] =
            convertToInt(msg[XBOX360_BTTN_RIGHT_TRIGGER_POS], 0);

  //
  // Left Joystick
  //
  val = convertToInt( msg[XBOX360_BTTN_LEFT_X_POS_L],
                      msg[XBOX360_BTTN_LEFT_X_POS_H] );

  if( val > m_nLeftJoyDeadZone )
  {
    m_state[Xbox360FeatIdLeftJoyX] = (int)(m_fLeftJoyM * val + m_fLeftJoyB);
  }
  else if( val < -m_nLeftJoyDeadZone )
  {
    m_state[Xbox360FeatIdLeftJoyX] = (int)(m_fLeftJoyM * val - m_fLeftJoyB);
  }
  else
  {
    m_state[Xbox360FeatIdLeftJoyX] = 0;
  }

  val = convertToInt( msg[XBOX360_BTTN_LEFT_Y_POS_L],
                      msg[XBOX360_BTTN_LEFT_Y_POS_H] );

  if( val > m_nLeftJoyDeadZone )
  {
    m_state[Xbox360FeatIdLeftJoyY] = (int)(m_fLeftJoyM * val + m_fLeftJoyB);
  }
  else if( val < -m_nLeftJoyDeadZone )
  {
    m_state[Xbox360FeatIdLeftJoyY] = (int)(m_fLeftJoyM * val - m_fLeftJoyB);
  }
  else
  {
    m_state[Xbox360FeatIdLeftJoyY] = 0;
  }

  //
  // Right Joystick
  //
  val = convertToInt( msg[XBOX360_BTTN_RIGHT_X_POS_L],
                      msg[XBOX360_BTTN_RIGHT_X_POS_H] );

  if( val > m_nRightJoyDeadZone )
  {
    m_state[Xbox360FeatIdRightJoyX] = (int)(m_fRightJoyM * val + m_fRightJoyB);
  }
  else if( val < -m_nRightJoyDeadZone )
  {
    m_state[Xbox360FeatIdRightJoyX] = (int)(m_fRightJoyM * val - m_fRightJoyB);
  }
  else
  {
    m_state[Xbox360FeatIdRightJoyX] = 0;
  }

  val = convertToInt( msg[XBOX360_BTTN_RIGHT_Y_POS_L],
                      msg[XBOX360_BTTN_RIGHT_Y_POS_H] );

  if( val > m_nRightJoyDeadZone )
  {
    m_state[Xbox360FeatIdRightJoyY] = (int)(m_fRightJoyM * val + m_fRightJoyB);
  }
  else if( val < -m_nRightJoyDeadZone )
  {
    m_state[Xbox360FeatIdRightJoyY] = (int)(m_fRightJoyM * val - m_fRightJoyB);
  }
  else
  {
    m_state[Xbox360FeatIdRightJoyY] = 0;
  }
}

void HIDXbox360::updateLEDState ( byte_t  buf[], ssize_t  n  )

protected

Update the LED pattern state.

Note

Wireless controller has LED state in the packet header for some idiotic reason.

Parameters

buf	Raw USB input buffer.
n	Length of data in buffer.

Definition at line 1749 of file HIDXbox360.cxx.

References m_nProdId, m_state, XBOX360_LED_MSG_LEN, XBOX360_LED_PAT_MASK, XBOX360_LED_PAT_POS, XBOX360_MSG_OFFSET_WL, XBOX360_WIRED_PROD_ID, XBOX360_WIRELESS_PROD_ID, XBOX360_WL_LED_PAT_POS, and rnr::Xbox360FeatIdLEDPat.

Referenced by parseWired().

{
  switch( m_nProdId )
  {
    case XBOX360_WIRELESS_PROD_ID:
    case XBOX360_WIRELESS_WIN_PROD_ID:
      if( n >= XBOX360_MSG_OFFSET_WL )
      {
        m_state[Xbox360FeatIdLEDPat] = buf[XBOX360_WL_LED_PAT_POS] &
                                            XBOX360_LED_PAT_MASK;
      }
      break;

    case XBOX360_WIRED_PROD_ID:
    default:
      if( n >= XBOX360_LED_MSG_LEN )
      {
        m_state[Xbox360FeatIdLEDPat] = buf[XBOX360_LED_PAT_POS] &
                                            XBOX360_LED_PAT_MASK;
      }
      break;
  }
}

void HIDXbox360::updateRumbleState ( byte_t  msg[], ssize_t  n  )

protected

Update the rumble motors state.

Parameters

msg	Message containing raw controller status data.
n	Length of data in message.

Definition at line 1726 of file HIDXbox360.cxx.

References convertToInt(), m_nProdId, m_state, XBOX360_RUMBLE_LEFT_POS, XBOX360_RUMBLE_MSG_LEN, XBOX360_RUMBLE_RIGHT_POS, XBOX360_WIRED_PROD_ID, XBOX360_WIRELESS_PROD_ID, rnr::Xbox360FeatIdLeftRumble, and rnr::Xbox360FeatIdRightRumble.

{
  switch( m_nProdId )
  {
    case XBOX360_WIRELESS_PROD_ID:
    case XBOX360_WIRELESS_WIN_PROD_ID:
      m_state[Xbox360FeatIdLeftRumble]  = msg[5];
      m_state[Xbox360FeatIdRightRumble] = msg[6];
      break;

    case XBOX360_WIRED_PROD_ID:
    default:
      if( n >= XBOX360_RUMBLE_MSG_LEN )
      {
        m_state[Xbox360FeatIdLeftRumble] = 
                            convertToInt(msg[XBOX360_RUMBLE_LEFT_POS], 0);
        m_state[Xbox360FeatIdRightRumble] =
                            convertToInt(msg[XBOX360_RUMBLE_RIGHT_POS], 0);
      }
      break;
  }
}

void * HIDXbox360::updateThread ( void *  pArg )

staticprotected

The update thread.

Parameters

pArg	Point to this class instance.

Returns

NULL

Definition at line 1895 of file HIDXbox360.cxx.

References blockWait(), rnr::HIDInput::isConnected(), m_eThreadState, ThreadStateExit, ThreadStateNone, ThreadStateRunning, and update().

Referenced by createUpdateThread(), and unlock().

{
  HIDXbox360 *pThis = (HIDXbox360 *)pArg;
  int         oldstate;
  int         rc;

  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate);

  LOGDIAG3("Update thread created.");

  while( (pThis->m_eThreadState == ThreadStateRunning) && pThis->isConnected() )
  {
    pThis->blockWait();

    switch( pThis->m_eThreadState )
    {
      case ThreadStateRunning:
        pThis->update(0);
        break;
      case ThreadStateExit:
      default:
        break;
    }
  }

  pThis->m_eThreadState = ThreadStateNone;

  LOGDIAG3("Update thread exited.");

  return NULL;
}

int rnr::HIDXbox360::updown ( int  nBit )

inlineprotected

Convert bit value to button up/down state.

Parameters

nBit	Bit value.

Returns

HID_BTTN_UP or HID_BTTN_DOWN

Definition at line 1167 of file HIDXbox360.h.

References cancelUpdateThread(), convertToInt(), createUpdateThread(), HID_BTTN_DOWN, and HID_BTTN_UP.

Referenced by updateButtonState().

    {
      return nBit != 0? HID_BTTN_DOWN: HID_BTTN_UP;
    }

void rnr::HIDXbox360::zeroState ( )

inlineprotected

Zero controller shadowed state.

Definition at line 1155 of file HIDXbox360.h.

Referenced by close(), HIDXbox360(), open(), and setLinkState().

    {
      memset(m_state, 0, sizeof(m_state));
    }

Member Data Documentation

pthread_cond_t rnr::HIDXbox360::m_condUpdate

protected

condition

Definition at line 983 of file HIDXbox360.h.

Referenced by blockWait(), HIDXbox360(), signalUpdateThread(), and ~HIDXbox360().

ThreadState rnr::HIDXbox360::m_eThreadState

protected

update thread state

Definition at line 980 of file HIDXbox360.h.

Referenced by cancelUpdateThread(), createUpdateThread(), HIDXbox360(), run(), stop(), and updateThread().

float rnr::HIDXbox360::m_fLeftJoyB

protected

left joystick y intercept

Definition at line 954 of file HIDXbox360.h.

Referenced by calibrateJoySticks(), and updateButtonState().

float rnr::HIDXbox360::m_fLeftJoyM

protected

left joystick slope

Definition at line 953 of file HIDXbox360.h.

Referenced by calibrateJoySticks(), and updateButtonState().

float rnr::HIDXbox360::m_fRightJoyB

protected

right joystick y intercept

Definition at line 957 of file HIDXbox360.h.

Referenced by calibrateJoySticks(), and updateButtonState().

float rnr::HIDXbox360::m_fRightJoyM

protected

right joystick slope

Definition at line 956 of file HIDXbox360.h.

Referenced by calibrateJoySticks(), and updateButtonState().

pthread_mutex_t rnr::HIDXbox360::m_mutexUpdate

protected

mutex

Definition at line 982 of file HIDXbox360.h.

Referenced by blockWait(), HIDXbox360(), and ~HIDXbox360().

int rnr::HIDXbox360::m_nBatteryStatus

protected

batter status

Definition at line 947 of file HIDXbox360.h.

Referenced by debugPrintState(), HIDXbox360(), and parseWireless().

int rnr::HIDXbox360::m_nErrorRcv

protected

consecutive rcv error count

Definition at line 966 of file HIDXbox360.h.

Referenced by checkErrorThresholds(), debugPrintState(), parseWireless(), transferCallbackInput(), transferCallbackLED(), and transferCallbackRumble().

int rnr::HIDXbox360::m_nErrorRcvTh

protected

consec rcv error threshold

Definition at line 967 of file HIDXbox360.h.

Referenced by checkErrorThresholds(), and setErrorThresholds().

int rnr::HIDXbox360::m_nErrorRcvTimeout

protected

consec rcv timeout error cnt

Definition at line 968 of file HIDXbox360.h.

Referenced by checkErrorThresholds(), debugPrintState(), parseWireless(), transferCallbackInput(), transferCallbackLED(), and transferCallbackRumble().

int rnr::HIDXbox360::m_nErrorRcvTimeoutTh

protected

consec rcv timeout error th

Definition at line 969 of file HIDXbox360.h.

Referenced by checkErrorThresholds(), and setErrorThresholds().

int rnr::HIDXbox360::m_nErrorSend

protected

consec send error count

Definition at line 970 of file HIDXbox360.h.

Referenced by debugPrintState(), setLED(), setRumble(), transferCallbackLED(), and transferCallbackRumble().

int rnr::HIDXbox360::m_nErrorTotal

protected

total error count

Definition at line 971 of file HIDXbox360.h.

Referenced by checkErrorThresholds(), debugPrintState(), parseWireless(), setLED(), setRumble(), transferCallbackInput(), transferCallbackLED(), and transferCallbackRumble().

int rnr::HIDXbox360::m_nErrorTotalTh

protected

total error threshold

Definition at line 972 of file HIDXbox360.h.

Referenced by checkErrorThresholds(), and setErrorThresholds().

int rnr::HIDXbox360::m_nLEDPattern

protected

target LED pattern

Definition at line 961 of file HIDXbox360.h.

Referenced by goad(), HIDXbox360(), open(), setLED(), setLinkState(), and transferCallbackLED().

int rnr::HIDXbox360::m_nLeftJoyDeadZone

protected

left joystick deadzone

Definition at line 952 of file HIDXbox360.h.

Referenced by calibrateJoySticks(), and updateButtonState().

int rnr::HIDXbox360::m_nLeftRumble

protected

target left rumble intensity

Definition at line 962 of file HIDXbox360.h.

Referenced by HIDXbox360(), open(), setRumble(), and transferCallbackRumble().

int rnr::HIDXbox360::m_nOffset

protected

start offset in message

Definition at line 949 of file HIDXbox360.h.

Referenced by HIDXbox360(), openXbox(), and parseWireless().

int rnr::HIDXbox360::m_nProdId

protected

Xbox USB product id.

Definition at line 944 of file HIDXbox360.h.

Referenced by claimXboxInterfaces(), close(), debugPrintHdr(), goad(), HIDXbox360(), isWireless(), open(), openXbox(), setLED(), setRumble(), transferCallbackInput(), updateLEDState(), and updateRumbleState().

int rnr::HIDXbox360::m_nRightJoyDeadZone

protected

right joystick deadzone

Definition at line 955 of file HIDXbox360.h.

Referenced by calibrateJoySticks(), and updateButtonState().

int rnr::HIDXbox360::m_nRightRumble

protected

target right rumble intensity

Definition at line 963 of file HIDXbox360.h.

Referenced by HIDXbox360(), open(), setRumble(), and transferCallbackRumble().

int rnr::HIDXbox360::m_nStatus

protected

raw status byte

Definition at line 948 of file HIDXbox360.h.

Referenced by close(), debugPrintState(), HIDXbox360(), and parseWireless().

int rnr::HIDXbox360::m_state[Xbox360FeatIdNumOf]

protected

current state

Definition at line 960 of file HIDXbox360.h.

Referenced by close(), debugPrintState(), getCurrentState(), getFeatureVal(), setFeatureVal(), transferCallbackLED(), transferCallbackRumble(), updateButtonState(), updateLEDState(), and updateRumbleState().

std::string rnr::HIDXbox360::m_strProdName

protected

product name

Definition at line 945 of file HIDXbox360.h.

Referenced by close(), debugPrintHdr(), and open().

std::string rnr::HIDXbox360::m_strSerialNum

protected

serial number

Definition at line 946 of file HIDXbox360.h.

Referenced by close(), and parseWireless().

pthread_t rnr::HIDXbox360::m_threadId

protected

update pthread identifier

Definition at line 984 of file HIDXbox360.h.

Referenced by cancelUpdateThread(), and createUpdateThread().

struct timespec rnr::HIDXbox360::m_tsThread

protected

update thread period

Definition at line 981 of file HIDXbox360.h.

Referenced by blockWait(), and run().

struct libusb_context* rnr::HIDXbox360::m_usbContext

protected

libusb session context

Definition at line 975 of file HIDXbox360.h.

Referenced by close(), HIDXbox360(), open(), openXbox(), update(), and ~HIDXbox360().

struct libusb_device_handle* rnr::HIDXbox360::m_usbHandle

protected

USB open handle.

Definition at line 976 of file HIDXbox360.h.

Referenced by claimXboxInterfaces(), close(), HIDXbox360(), initTransferPkts(), open(), and openXbox().

UsbPkt_T rnr::HIDXbox360::m_usbPkt[UsbPktIdNumOf]

protected

USB transfer packets.

Definition at line 977 of file HIDXbox360.h.

Referenced by cancelTransfers(), freeTransferPkts(), goad(), HIDXbox360(), initTransferPkts(), setLED(), setRumble(), submitReadTransfer(), transferCallbackGoad(), transferCallbackInput(), transferCallbackLED(), and transferCallbackRumble().

const int rnr::HIDXbox360::NErrorRcvThDft = 5

static

Consecutive receive errors threshold default.

Definition at line 661 of file HIDXbox360.h.

const int rnr::HIDXbox360::NErrorRcvTimeoutThDft = 0

static

Consecutive receive timeouts threshold default.

Definition at line 658 of file HIDXbox360.h.

const int rnr::HIDXbox360::NErrorTotalThDft = 0

static

Total receive errors threshold default.

Definition at line 664 of file HIDXbox360.h.

const int rnr::HIDXbox360::UsbTransferBufSize = 32

static

Transfer buffer maximum byte size.

Definition at line 655 of file HIDXbox360.h.

---

The documentation for this class was generated from the following files:

• include/rnr/hid/HIDXbox360.h
• sw/libhid/HIDXbox360.cxx