Inheritance diagram for JoystickDrive:

Collaboration diagram for JoystickDrive:

Public Member Functions
	JoystickDrive (unsigned int uL, const DriveHandler *pDH, const std::string &sFileName, integer nButtons, const std::vector< doublereal > &lc_scale, const std::vector< doublereal > &v0)

virtual	~JoystickDrive (void)

virtual std::ostream &	Restart (std::ostream &out) const

virtual void	ServePending (const doublereal &t)

Public Member Functions inherited from FileDrive
	FileDrive (unsigned int uL, const DriveHandler *pDH, const std::string &s, integer nd, const std::vector< doublereal > &v0)

virtual	~FileDrive (void)

virtual Drive::Type	GetDriveType (void) const

virtual integer	iGetNumDrives (void) const

virtual doublereal	dGet (const doublereal &t, int i=1) const

Public Member Functions inherited from Drive
	Drive (unsigned int uL, const DriveHandler *pDH)

virtual	~Drive (void)

Public Member Functions inherited from WithLabel
	WithLabel (unsigned int uL=0, const std::string &sN="")

virtual	~WithLabel (void)

void	PutLabel (unsigned int uL)

void	PutName (const std::string &sN)

unsigned int	GetLabel (void) const

const std::string &	GetName (void) const

Private Member Functions
bool	get_one (void)

void	init (void)

bool	get_fd_flags (void)

bool	set_fd_blocking (bool bBlocking)

Private Attributes
int	m_fd

std::vector< bool >	m_b_reset

integer	m_nButtons

std::vector< doublereal >	m_lc_scale

integer	m_nLC

doublereal *	m_pdLC

doublereal *	m_pdB

int	m_flags

Additional Inherited Members
Public Types inherited from Drive
enum	Type { UNKNOWN = -1, FILEDRIVE = 0, LASTDRIVETYPE }

enum	Bailout { BO_NONE = 0x0, BO_UPPER = 0x1, BO_LOWER = 0x2, BO_ANY = (BO_UPPER \| BO_LOWER) }

Protected Attributes inherited from FileDrive
std::string	sFileName

integer	iNumDrives

doublereal *	pdVal

Protected Attributes inherited from Drive
const DriveHandler *	pDrvHdl

Protected Attributes inherited from WithLabel
unsigned int	uLabel

std::string	sName

Static Protected Attributes inherited from Drive
static doublereal	dReturnValue = 0.

Detailed Description

Definition at line 43 of file module-hid.cc.

Constructor & Destructor Documentation

JoystickDrive::JoystickDrive	(	unsigned int	uL,
		const DriveHandler *	pDH,
		const std::string &	sFileName,
		integer	nButtons,
		const std::vector< doublereal > &	lc_scale,
		const std::vector< doublereal > &	v0
	)

Definition at line 78 of file module-hid.cc.

 : FileDrive(uL, pDH, sFileName, nButtons + lc_scale.size(), v0),
 m_fd(-1),
 m_b_reset(nButtons), m_nButtons(nButtons),
 m_lc_scale(lc_scale), m_nLC(m_lc_scale.size()),
 m_pdLC(pdVal + 1), m_pdB(m_pdLC + m_nLC)
 {
 }

JoystickDrive::~JoystickDrive ( void )

virtual

Definition at line 90 of file module-hid.cc.

References m_fd.

 {
         if (m_fd != -1) {
                 close(m_fd);
         }
         m_fd = -1;
 }

Member Function Documentation

bool JoystickDrive::get_fd_flags ( void )

private

Definition at line 99 of file module-hid.cc.

References m_fd, and m_flags.

Referenced by init().

 {
         m_flags = fcntl(m_fd, F_GETFL, 0);
         if (m_flags == -1) {
                 return false;
         }
 
         return true;
 }

bool JoystickDrive::get_one ( void )

private

Definition at line 127 of file module-hid.cc.

References buf, m_b_reset, m_fd, m_lc_scale, m_nButtons, m_nLC, m_pdB, m_pdLC, MBDYN_EXCEPT_ARGS, read(), set_fd_blocking(), FileDrive::sFileName, and WithLabel::uLabel.

Referenced by ServePending().

 {
         fd_set readfds;
         FD_ZERO(&readfds);
         FD_SET(m_fd, &readfds);
         struct timeval tv = { 0, 0 };
         int rc = select(m_fd + 1, &readfds, NULL, NULL, &tv);
 
 #ifdef HID_DEBUG
         std::cerr << "select=" << rc << std::endl;
 #endif // HID_DEBUG
 
         switch (rc) {
         case -1: {
                 int save_errno = errno;
                 char *err_msg = strerror(save_errno);
 
                 silent_cout("JoystickDrive(" << uLabel << ", " << sFileName << "): select failed"
                         << " (" << save_errno << ": " << err_msg << ")" << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
 
         case 0:
                 return true;
 
         default:
                 if (!FD_ISSET(m_fd, &readfds)) {
                         silent_cout("JoystickDrive"
                                 "(" << sFileName << "): "
                                 "socket " << m_fd << " reset"
                                 << std::endl);
                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
         }
 
         // toggle blocking to make sure we get the whole package
         char buf[8];
         set_fd_blocking(true);
         ssize_t n2 = read(m_fd, (void *)&buf[0], sizeof(buf));
         set_fd_blocking(false);
         if (n2 == -1) {
 #ifdef HID_DEBUG
                 int save_errno = errno;
                 std::cerr << "recv=" << save_errno << " " << strerror(save_errno) << std::endl;
 #endif // HID_DEBUG
         }
 
 #ifdef HID_DEBUG
         uint32_t cnt = *((uint32_t *)&buf[0]);
 #endif // HID_DEBUG
         uint8_t type = (uint8_t)buf[6];
         uint8_t idx = (uint8_t)buf[7];
         int16_t value = *((int16_t *)&buf[4]);
 
 #ifdef HID_DEBUG
         std::cerr << "n2=" << n2 << " cnt=" << cnt << " value=" << int(value) << " type=" << unsigned(type) << " idx=" << unsigned(idx) << std::endl;
 #endif // HID_DEBUG
 
         switch (type) {
         case 1:
                 // buttons
                 if (idx < m_nButtons) {
                         /*
                          * when a button is pressed, an event
                          * with non-zero value is recorded;
                          * when the button is released, an event
                          * with zero value is recorded.
                          *
                          * when we see an event with non-zero value,
                          * we set the value to 1., and clear
                          * the "reset" flag; when we see an event with
                          * zero value, we set the reset flag.
                          *
                          * if the button was not previously set,
                          * and it is pressed between two calls to
                          * ServePending(), at the end it is set
                          * and not scheduled for clear.
                          *
                          * if the button was set, and it is 
                          * released between two calls to ServePending(),
                          * it is scheduled for clear.
                          *
                          * if the button is pressed and released
                          * multiple times between two calls,
                          * it remains set to 1. and scheduled for clear.
                          */
                         if (value) {
                                 m_pdB[idx] = 1.;
                                 m_b_reset[idx] = false;
 
                         } else {
                                 m_b_reset[idx] = true;
                         }
                 }
                 // else ignore
                 break;
 
         case 2:
                 // linear controls
 
                 /*
                  * linear controls vary either between 0 and UINT16_MAX
                  * or between -INT16_MAX and INT16_MAX.
                  *
                  * FIXME: currently, we assume -INT16_MAX and INT16_MAX.
                  *
                  * we simply record the last value, and scale it.
                  */
                 if (idx < m_nLC) {
                         m_pdLC[idx] = (m_lc_scale[idx]*value)/INT16_MAX;
                 }
                 break;
 
         default:
                 // ignore
                 break;
         }
 
         return false;
 }

Here is the call graph for this function:

void JoystickDrive::init ( void )

private

Definition at line 249 of file module-hid.cc.

References buf, get_fd_flags(), m_fd, m_nButtons, m_nLC, MBDYN_EXCEPT_ARGS, read(), set_fd_blocking(), FileDrive::sFileName, and WithLabel::uLabel.

Referenced by ServePending().

 {
         m_fd = open(sFileName.c_str(), O_RDONLY);
         if (m_fd == -1) {
                 int save_errno = errno;
                 silent_cerr("JoystickDrive(" << uLabel << ", " << sFileName << ")::init(): "
                         "unable to open device <" << sFileName << "> "
                         "(" << save_errno << ": " << strerror(save_errno) << ")"
                 << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         // this probably contains the description of the channels...
         integer nB = 0, nLC = 0;
         uint8_t iBmax = 0, iLCmax = 0;
         for (int i = 0; i < m_nLC + m_nButtons; i++) {
                 char buf[8];
                 ssize_t n = read(m_fd, (void *)&buf[0], sizeof(buf));
 
 #ifdef HID_DEBUG
                 std::cerr << "read idx=" << i << " n=" << n << std::endl;
 #endif // HID_DEBUG
 
                 if (n == -1) {
                         int save_errno = errno;
                         silent_cerr("JoystickDrive(" << uLabel << ", " << sFileName << ")::init(): "
                                 "read failed (" << save_errno << ": " << strerror(save_errno) << ")"
                                 << std::endl);
                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
 
                 uint8_t type = (uint8_t)buf[6];
                 uint8_t idx = (uint8_t)buf[7];
                 // int16_t value = *((int16_t *)&buf[4]);
                 if ((type & 0x7F) == 1) {
                         nB++;
                         iBmax = std::max(iBmax, idx);
 
                 } else if ((type & 0x7F) == 2) {
                         nLC++;
                         iLCmax = std::max(iLCmax, idx);
 
                 } else {
                         silent_cerr("JoystickDrive(" << uLabel << ", " << sFileName << "): "
                                 "warning, unknown type " << int(type & 0x7F) << ", ignored" << std::endl); }
 
 #ifdef HID_DEBUG
                 std::cerr << "    type=" << uint(type) << " idx=" << uint(idx) << " value=" << value << std::endl;
 #endif // HID_DEBUG
         }
 
         bool bFail(false);
         if (nB != m_nButtons) {
                 silent_cerr("JoystickDrive(" << uLabel << ", " << sFileName << "): "
                         "inconsistent number of buttons: expected " << m_nButtons << ", got " << nB << std::endl);
                 bFail = true;
         }
 
         if (iBmax >= m_nButtons) {
                 silent_cerr("JoystickDrive(" << uLabel << ", " << sFileName << "): "
                         "inconsistent largest button index: expected " << m_nButtons - 1 << ", got " << unsigned(iBmax) << std::endl);
                 bFail = true;
         }
 
         if (nLC != m_nLC) {
                 silent_cerr("JoystickDrive(" << uLabel << ", " << sFileName << "): "
                         "inconsistent number of linear controls: expected " << m_nLC << ", got " << nLC << std::endl);
                 bFail = true;
         }
 
         if (iLCmax >= m_nLC) {
                 silent_cerr("JoystickDrive(" << uLabel << ", " << sFileName << "): "
                         "inconsistent largest linear control index: expected " << m_nLC - 1 << ", got " << unsigned(iLCmax) << std::endl);
                 bFail = true;
         }
 
         if (bFail) {
                 // TODO: error
         }
 
         get_fd_flags();
         set_fd_blocking(false);
 }

Here is the call graph for this function:

std::ostream & JoystickDrive::Restart ( std::ostream & out ) const

virtual

Implements FileDrive.

Definition at line 334 of file module-hid.cc.

 {
         return out << "# not implemented yet" << std::endl;
 }

void JoystickDrive::ServePending ( const doublereal & t )

virtual

Implements Drive.

Definition at line 340 of file module-hid.cc.

References get_one(), init(), m_b_reset, m_fd, m_nButtons, m_nLC, m_pdB, NO_OP, FileDrive::pdVal, and FileDrive::sFileName.

 {
         if (m_fd == -1) {
                 init();
         }
 
         // reset if needed
         for (integer idx = 0; idx < m_nButtons; idx++) {
                 if (m_b_reset[idx]) {
                         m_pdB[idx] = 0.;
                         m_b_reset[idx] = false;
                 }
         }
 
         // flush buffer
         while (!get_one()) { NO_OP; };
 
 #ifdef HID_DEBUG
         std::cerr << "JoystickDrive(" << sFileName << ")" << std::endl;
         for (int i = 0; i < m_nLC + m_nButtons; i++) {
                 std::cerr << "    V[" << i << "]=" << pdVal[i] << std::endl;
         }
 #endif // HID_DEBUG
 }

Here is the call graph for this function:

bool JoystickDrive::set_fd_blocking ( bool bBlocking )

private

Definition at line 110 of file module-hid.cc.

References m_fd, and m_flags.

Referenced by get_one(), and init().

 {
         int rc;
 
         if (bBlocking) {
                 m_flags &= ~O_NONBLOCK;
 
         } else {
                 m_flags |= O_NONBLOCK;
         }
 
         rc = fcntl(m_fd, F_SETFL, m_flags);
 
         return (rc != -1);
 }