PacketUsbCdc::Status PacketUsbCdc::close()
{
exit = true;
usbClose( );
msleep( 50 ); // wait a second before returning, because we'll be deleted right after we're removed form the GUI
return PacketInterface::OK;
}
int main(int argc, char **argv)
{
driver glove = driver();
// Initialize ncurses
nc_init();
FILE * file = fopen("output.dat", "w");
for(int key;;) {
// User hat eine Taste gedrückt
if ((key = getch()) != ERR) {
break;
}
// Daten abrufen
int_least16_t x(0), y(0), z(0), test(0);
clock_t start = clock();
glove.catch_data(x, y, z, test);
clock_t end = clock();
fprintf(file, "%d %d %d\n", x, y, z);
setStatus(x, y, z, start, end, test);
}
usbClose();
fclose(file);
endwin();
return 0;
}
UsbSerial::UsbStatus UsbSerial::usbWrite( char* buffer, int length )
{
if( !deviceOpen )
{
UsbStatus portIsOpen = usbOpen( );
if( portIsOpen != OK )
{
usbClose( );
return NOT_OPEN;
}
}
QMutexLocker locker( &usbMutex );
// Linux Only
#if (defined(Q_WS_LINUX))
return NOT_OPEN;
#endif
//Mac-only
#ifdef Q_WS_MAC
int size = ::write( deviceHandle, buffer, length );
if ( length == size )
return OK;
else if( errno == EAGAIN )
return NOTHING_AVAILABLE;
else
return IO_ERROR;
#endif //Mac-only UsbSerial::write( )
//Windows-only
#ifdef Q_WS_WIN
DWORD cout, ret, numWritten;
bool success;
UsbSerial::UsbStatus retval = OK;
overlappedWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
// reset the write overlapped structure
overlappedWrite.Offset = overlappedWrite.OffsetHigh = 0;
success = WriteFile( deviceHandle, buffer, length, &cout, &overlappedWrite );
if( !success )
{
if ( GetLastError() == ERROR_IO_PENDING)
{
int waitCount = 0;
do
{
if( waitCount++ > 5 )
break;
ret = WaitForSingleObject( overlappedWrite.hEvent, 100 );
} while ( ret == WAIT_TIMEOUT );
if ( ret == WAIT_OBJECT_0 )
{
//do
//{
GetOverlappedResult( deviceHandle, &overlappedWrite, &numWritten, TRUE);
//read = numWritten;
//} while( read != length );
if( numWritten == (DWORD)length )
retval = OK;
else
retval = IO_ERROR;
}
else
retval = IO_ERROR;
}
else
{
//usbClose( );
retval = IO_ERROR;
}
}
CloseHandle( overlappedWrite.hEvent );
return retval;
#endif //Windows-only UsbSerial::write( )
}
int UsbSerial::usbRead( char* buffer, int length )
{
// make sure we're open
if( !deviceOpen )
{
UsbStatus portIsOpen = usbOpen( );
if( portIsOpen != OK )
{
usbClose( );
return NOT_OPEN;
}
}
QMutexLocker locker( &usbMutex );
// Linux Only
#if (defined(Q_WS_LINUX))
// make sure we're open
//if( !deviceOpen )
return NOT_OPEN;
#endif
//Mac-only
#ifdef Q_WS_MAC
int count;
count = ::read( deviceHandle, buffer, length );
if( count > 1 )
return count;
else
{
switch ( count )
{
case 0:
return ERROR_CLOSE; // EOF; possibly file was closed
break;
case -1:
if ( errno == EAGAIN )
return NOTHING_AVAILABLE;
else
return IO_ERROR;
break;
}
}
return 0; // should never get here
#endif //Mac-only UsbSerial::read( )
//Windows-only///////////////////////////////////////////////////////////////////////
#ifdef Q_WS_WIN
DWORD count;
int retval = -1;
DWORD numTransferred;
retval = OK;
readInProgress = false;
overlappedRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
// reset the read overlapped structure
overlappedRead.Offset = overlappedRead.OffsetHigh = 0;
if ( !ReadFile( deviceHandle, buffer, length, &count, &overlappedRead ) )
{
DWORD lastError = GetLastError();
// messageInterface->message( 1, "USB Read Error: %d \n", lastError );
if ( lastError != ERROR_IO_PENDING) // read not delayed?
{
usbClose( );
//messageInterface->message( 1, "Closed trying to read the file\n" );
retval = -1; //UNKNOWN_ERROR;
}
else
readInProgress = true;
}
else
retval = count;
if( readInProgress )
{
DWORD r;
do
{
r = WaitForSingleObject( overlappedRead.hEvent, 1000 );
} while ( r == WAIT_TIMEOUT );
switch( r )
{
case WAIT_FAILED:
usbClose( );
retval = -1; //UNKNOWN_ERROR;
break;
case WAIT_TIMEOUT:
retval = -1; // NOTHING_AVAILABLE;
break;
case WAIT_OBJECT_0:
// check to see if the pending operation completed
if( !GetOverlappedResult( deviceHandle, &overlappedRead, &numTransferred, FALSE ) ) // don't wait
{
usbClose( );
SetEvent( overlappedRead.hEvent );
retval = -1; //IO_ERROR;
break;
}
retval = numTransferred;
break;
case WAIT_ABANDONED:
default:
usbClose( );
retval = -1; //IO_ERROR;
break;
} // end of switch
}
CloseHandle( overlappedRead.hEvent );
return retval;
#endif //Windows-only UsbSerial::read( )//////////////////////////////////////////////////////////////
}
PacketUsbCdc::Status PacketUsbCdc::close()
{
usbClose( );
return PacketInterface::OK;
}
PacketUsbCdc::Status PacketUsbCdc::close()
{
usbWriteChar( END );
usbClose( );
return PacketInterface::OK;
}
UsbSerial::UsbStatus UsbSerial::usbWrite( char* buffer, int length )
{
// Linux Only
#if (defined(Q_WS_LINUX))
// make sure we're open
//if( !deviceOpen )
return NOT_OPEN;
#endif
//Mac-only
#ifdef Q_WS_MAC
if( !deviceOpen ) //then try to open it
{
UsbStatus portIsOpen = usbOpen( );
if( portIsOpen != OK )
return NOT_OPEN;
}
int size = ::write( deviceHandle, buffer, length );
if ( length == size )
return OK;
else if( errno == EAGAIN )
return NOTHING_AVAILABLE;
else
{
//printf("usbWrite: write failed, errno %d", errno);
usbClose( );
return IO_ERROR;
}
#endif //Mac-only UsbSerial::write( )
//Windows-only
#ifdef Q_WS_WIN
DWORD cout;
int count = 1;
bool success;
DWORD ret;
UsbSerial::UsbStatus retval = OK;
DWORD numWritten;
if( !deviceOpen )
{
UsbStatus portIsOpen = usbOpen( );
if( portIsOpen != OK )
{
usbClose( );
return NOT_OPEN;
}
}
overlappedWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
// reset the write overlapped structure
overlappedWrite.Offset = overlappedWrite.OffsetHigh = 0;
// messageInterface->message( 1, "Writing...\n" );
success = WriteFile( deviceHandle, buffer, count, &cout, &overlappedWrite ) ;
if( !success )
{
if ( GetLastError() == ERROR_IO_PENDING)
{
// messageInterface->message( 1, "Write: IO PENDING.\n" );
do
{
//if( debug > 4 )TRACE_MESSAGE("TI_put(): Waiting for overlapped write to complete");
ret = WaitForSingleObject( overlappedWrite.hEvent, 1000 );
} while ( ret == WAIT_TIMEOUT );
if ( ret == WAIT_OBJECT_0 )
{
// messageInterface->message( 1, "Write: IO PENDING.\n" );
GetOverlappedResult( deviceHandle, &overlappedWrite, &numWritten, TRUE);
if( count == numWritten )
{
// messageInterface->message( 1, "Write: COMPLETE.\n" );
retval = OK;
}
else
{
// messageInterface->message( 1, "write event, but only wrote %d\n", numWritten );
usbClose( );
retval = IO_ERROR;
}
}
else
{
usbClose( );
retval = IO_ERROR;
}
}
else
{
usbClose( );
retval = IO_ERROR;
}
}
CloseHandle( overlappedWrite.hEvent );
return retval;
#endif //Windows-only UsbSerial::write( )
}
UsbSerial::UsbStatus UsbSerial::usbRead( char* buffer, int length )
{
// Linux Only
#if (defined(Q_WS_LINUX))
// make sure we're open
//if( !deviceOpen )
return NOT_OPEN;
#endif
//Mac-only
#ifdef Q_WS_MAC
int count;
if( !deviceOpen )
{
UsbStatus portIsOpen = usbOpen( );
if( portIsOpen == OK )
deviceOpen = true;
else
return NOT_OPEN;
}
count = ::read( deviceHandle, buffer, length );
printf( "Reading...count = %d\n", count );
switch ( count )
{
case 0:
// EOF; possibly file was closed
//printf( "End of file.\n" );
return ERROR_CLOSE;
break;
case 1:
// got a character
//printf( "Got a character: %s\n", buffer );
return GOT_CHAR;
break;
case -1:
if ( errno == EAGAIN )
{
// non-blocking but no data available
//printf( "No data available.\n" );
return NOTHING_AVAILABLE;
}
else
//printf( "Some other error...\n" );
return IO_ERROR;
break;
default:
//printf( "Unknown error.\n" );
return IO_ERROR;
break;
}
return OK;
#endif //Mac-only UsbSerial::read( )
//Windows-only///////////////////////////////////////////////////////////////////////
#ifdef Q_WS_WIN
DWORD count;
UsbStatus retval;
DWORD numTransferred;
//int length = 0;
// make sure we're open
if( !deviceOpen )
{
UsbStatus portIsOpen = usbOpen( );
if( portIsOpen != OK )
{
usbClose( );
return NOT_OPEN;
}
}
retval = OK;
readInProgress = false;
overlappedRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
// reset the read overlapped structure
overlappedRead.Offset = overlappedRead.OffsetHigh = 0;
if ( !ReadFile( deviceHandle, buffer, length, &count, &overlappedRead ) )
{
DWORD lastError = GetLastError();
// messageInterface->message( 1, "USB Read Error: %d \n", lastError );
if ( lastError != ERROR_IO_PENDING) // read not delayed?
{
usbClose();
//messageInterface->message( 1, "Closed trying to read the file\n" );
retval = UNKNOWN_ERROR;
}
else
readInProgress = true;
}
else
{
// messageInterface->message( 1, "USB read D: %c \n", *buffer );
retval = GOT_CHAR;
}
if( readInProgress )
{
DWORD r;
do
{
r = WaitForSingleObject( overlappedRead.hEvent, 10000 );
} while ( r == WAIT_TIMEOUT );
switch( r )
{
case WAIT_FAILED:
//FIXME is there anything else i need to clean up?
// reset events? terminate anything?
usbClose( );
//messageInterface->message( 1, "Closed after wait failed\n" );
retval = UNKNOWN_ERROR; //( 100 );
break;
case WAIT_TIMEOUT:
//if( debug > 1 ) TRACE_MESSAGE( "timeout occurred while waiting for event\n" );
retval = NOTHING_AVAILABLE; //( TELEO_E_NOTHING );
//messageInterface->message( 1, "Nothing available\n" );
break;
case WAIT_OBJECT_0:
// check to see if the pending operation completed
if( !GetOverlappedResult( deviceHandle, &overlappedRead, &numTransferred, FALSE ) ) // don't wait
{
///FIXME is there anything else i need to clean up?
// reset events? terminate anything?
usbClose( );
SetEvent( overlappedRead.hEvent );
//messageInterface->message( 1, "Closed because error getting overlapped result\n" );
retval = IO_ERROR;
break;
}
//messageInterface->message( 1, "Successfully got overlapped result\n" );
retval = GOT_CHAR;
break;
case WAIT_ABANDONED:
default:
usbClose( );
//messageInterface->message( 1, "Closed - wait abandoned or default\n" );
retval = IO_ERROR;
break;
} // end of switch
}
CloseHandle( overlappedRead.hEvent );
return retval;
#endif //Windows-only UsbSerial::read( )//////////////////////////////////////////////////////////////
}
int Sdr1kUsb::Open(BOOL rfe, BOOL adc, int select)
{
if (usbStatus >= 0) Close();
GetNumDevs();
int idx = select;
if (select < 0) idx = 0;
while (idx < devcount) {
if (usbOpen(device[idx])) {
if (usbSetConfiguration(1) == 0
&& usbClaimInterface(0) == 0
&& usbSetAltinterface(1) == 0)
{
usbStatus = 0;
break;
}
usbClose();
}
if (select < 0) idx++;
else return usbStatus;
}
if (usbStatus < 0) return usbStatus;
#ifdef SDR1KUSB_INFO
printf("device %d: %s\n", idx, device[idx]->filename);
printf("hardware: %s\n", hw[idx]->name);
#endif
inEP = hw[idx]->inEP;
outEP = hw[idx]->outEP;
usbClearHalt(inEP);
usbClearHalt(outEP);
int* fwSize = hw[idx]->fwSize;
int* fwAddr = hw[idx]->fwAddr;
BYTE** fwBytes = hw[idx]->fwBytes;
for (int i = 0; fwSize[i] > 0; i++) {
ezusbFirmwareDownload(fwAddr[i], fwBytes[i], fwSize[i]);
}
int eepromSize = hw[idx]->eepromSize;
if (eepromSize == 16) {
BYTE eeprom[16];
usbBulkRead(inEP, eeprom, 16);
#ifdef SDR1KUSB_INFO
printf("EEPROM:");
for (int i = 0; i < 16; i++) {
printf(" %02X", eeprom[i]);
}
printf("\n");
#endif
}
inputEvent = 0;
usbUpdatePeriod = USB_UPDATE_DEFAULT;
outcount = 0;
startUsbThread();
Latch(0x0F, 0);
DDSReset();
rfeEnabled = rfe;
if (rfeEnabled) {
LatchBpf(0); // bpfBits |= 0x24
adcEnabled = adc;
SRLoadIC11(0);
SRLoadIC7(0);
SRLoadIC10(0);
SRLoadIC9(0);
}
else adcEnabled = 0;
if (Commit() < 0) {
Close();
return usbStatus;
}
return idx;
}
