/*
* Class: kinetic_Kinetic1090Puck
* Method: puckOpen
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_kinetic_Kinetic1090Puck_puckOpen(JNIEnv *env, jobject obj)
{
// open the device
FT_STATUS ftStatus = FT_OpenEx("Kinetic 1090 Puck Beavis 3A B", FT_OPEN_BY_DESCRIPTION, &ftHandle);
if (ftStatus != FT_OK) {
return -1;
}
// set the baud rate
ftStatus = FT_SetBaudRate(ftHandle, 3000000);
if (ftStatus != FT_OK) {
return -1;
}
// set the data characteristics
ftStatus = FT_SetDataCharacteristics(ftHandle, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE);
if (ftStatus != FT_OK) {
return -1;
}
// set flow control
ftStatus = FT_SetFlowControl(ftHandle, FT_FLOW_NONE, 0x11, 0x13);
if (ftStatus != FT_OK) {
return -1;
}
// set read and write timeouts
ftStatus = FT_SetTimeouts(ftHandle, 5000, 1000);
if (ftStatus != FT_OK) {
return -1;
}
return 0;
}
FT_STATUS ftdimut_setup() {
FT_STATUS ftStatus;
unsigned char timer;
ftStatus = FT_SetVIDPID(USB_VID, USB_PID);
if(ftStatus != FT_OK) return ftStatus;
ftStatus = FT_Open(0, &ftHandle);
if(ftStatus != FT_OK) return ftStatus;
ftStatus = FT_ResetDevice(ftHandle);
if(ftStatus != FT_OK) return ftStatus;
ftStatus = FT_Purge(ftHandle, FT_PURGE_RX | FT_PURGE_TX);
if(ftStatus != FT_OK) return ftStatus;
ftStatus = FT_SetBaudRate(ftHandle, 15625);
if(ftStatus != FT_OK) return ftStatus;
ftStatus = FT_SetDataCharacteristics(ftHandle, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE);
if(ftStatus != FT_OK) return ftStatus;
ftStatus = FT_SetFlowControl(ftHandle, FT_FLOW_NONE, 0, 0);
if(ftStatus != FT_OK) return ftStatus;
ftStatus = FT_SetTimeouts(ftHandle, 1000, 1000);
if(ftStatus != FT_OK) return ftStatus;
ftStatus = FT_GetLatencyTimer(ftHandle, &timer);
if(ftStatus != FT_OK) return ftStatus;
ftStatus = FT_SetLatencyTimer(ftHandle, 1);
if(ftStatus != FT_OK) return ftStatus;
return FT_OK;
}
bool FtdiDevices::setFlowControl() {
USHORT FlowControl;
UCHAR XonChar;
UCHAR XoffChar;
FT_STATUS ftStatus;
FlowControl = FT_FLOW_NONE;
XonChar = 0;
XoffChar = 0;
switch(FT_INDEX_FLOW_NONE) {
case 0: // NONE
default:
break;
case 1: // RTS
FlowControl = FT_FLOW_RTS_CTS;
break;
case 2: // DTR
FlowControl = FT_FLOW_DTR_DSR;
break;
case 3: // XON/XOFF
FlowControl = FT_FLOW_XON_XOFF;
XonChar = 0x11;
XoffChar = 0x13;
break;
}
ftStatus = FT_SetFlowControl(m_ftHandleA, FlowControl, XonChar, XoffChar);
if (!FT_SUCCESS(ftStatus)) {
return false;
}
return true;
}
void TellStick::aquireTellStick() {
char *tempSerial = new char[serial().size()+1];
#ifdef _WINDOWS
strcpy_s(tempSerial, serial().size()+1, serial().toLocal8Bit());
#else
strcpy(tempSerial, serial().toLocal8Bit());
int pid = 0x0C30;
if (type() == 2) {
pid = 0x0C31;
}
FT_SetVIDPID(0x1781, pid);
#endif
FT_STATUS ftStatus = FT_OpenEx(tempSerial, FT_OPEN_BY_SERIAL_NUMBER, &d->ftHandle);
delete tempSerial;
if (ftStatus != FT_OK) {
return;
}
//open = true;
if (type() == 2) {
FT_SetBaudRate(d->ftHandle, 115200);
} else {
FT_SetBaudRate(d->ftHandle, 9600);
}
FT_SetFlowControl(d->ftHandle, FT_FLOW_NONE, 0, 0);
FT_SetTimeouts(d->ftHandle,1000,0);
setUpgradeStep(2);
QTimer::singleShot(0, this, SLOT(enterBootloader()));
}
QString FTD2XXInterface::readLabel(uchar label, int *ESTA_code)
{
FT_HANDLE ftdi = NULL;
if (FT_Open(id(), &ftdi) != FT_OK)
return QString();
if(FT_ResetDevice(ftdi) != FT_OK)
return QString();
if(FT_SetBaudRate(ftdi, 250000) != FT_OK)
return QString();
if(FT_SetDataCharacteristics(ftdi, FT_BITS_8, FT_STOP_BITS_2, FT_PARITY_NONE) != FT_OK)
return QString();
if(FT_SetFlowControl(ftdi, 0, 0, 0) != FT_OK)
return QString();
QByteArray request;
request.append(ENTTEC_PRO_START_OF_MSG);
request.append(label);
request.append(ENTTEC_PRO_DMX_ZERO); // data length LSB
request.append(ENTTEC_PRO_DMX_ZERO); // data length MSB
request.append(ENTTEC_PRO_END_OF_MSG);
DWORD written = 0;
if (FT_Write(ftdi, (char*) request.data(), request.size(), &written) != FT_OK)
return QString();
if (written == 0)
{
qDebug() << Q_FUNC_INFO << "Cannot write data to device";
return QString();
}
uchar* buffer = (uchar*) malloc(sizeof(uchar) * 40);
Q_ASSERT(buffer != NULL);
int read = 0;
QByteArray array;
FT_SetTimeouts(ftdi, 500,0);
FT_Read(ftdi, buffer, 40, (LPDWORD) &read);
qDebug() << Q_FUNC_INFO << "----- Read: " << read << " ------";
for (int i = 0; i < read; i++)
array.append((char) buffer[i]);
if (array[0] != ENTTEC_PRO_START_OF_MSG)
qDebug() << Q_FUNC_INFO << "Reply message wrong start code: " << QString::number(array[0], 16);
*ESTA_code = (array[5] << 8) | array[4];
array.remove(0, 6); // 4 bytes of Enttec protocol + 2 of ESTA ID
array.replace(ENTTEC_PRO_END_OF_MSG, '\0'); // replace Enttec termination with string termination
FT_Close(ftdi);
return QString(array);
}
bool CMmcUsbHndlBase::Configure()
{
if( !AreLibraryFunctionsLoaded() )
{
perror("Library not loaded");
return false;
}
bool oResult = true;
const BYTE LATENCY_TIMER(2);
const DWORD INPUT_TRANSFER_SIZE(128);
const DWORD OUTPUT_TRANSFER_SIZE(128);
FT_STATUS ftStatus = FT_OK;
//Data Characteristics:ByteSize, StopBit, Parity
if(FT_OK != (ftStatus = FT_SetDataCharacteristics(m_Handle, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE)))
{
std::string errormsg = GetFtStatusDescription(ftStatus);
errormsg += ":FT_SetDataCharacteristics";
perror(errormsg.c_str());
oResult = false;
}
//FlowControl: Dtr, Rts, Xon, Xoff
if(FT_OK != (ftStatus = FT_SetFlowControl(m_Handle, FT_FLOW_NONE, 0, 0)))
{
std::string errormsg = GetFtStatusDescription(ftStatus);
errormsg += ":FT_SetFlowControl";
perror(errormsg.c_str());
oResult = false;
}
//LatencyTimer
if(FT_OK != (ftStatus = FT_SetLatencyTimer(m_Handle, LATENCY_TIMER)))
{
std::string errormsg = GetFtStatusDescription(ftStatus);
errormsg += ":FT_SetLatencyTimer";
perror(errormsg.c_str());
oResult = false;
}
//TransferSize
if(FT_OK != (ftStatus = FT_SetUSBParameters(m_Handle, INPUT_TRANSFER_SIZE, OUTPUT_TRANSFER_SIZE)))
{
std::string errormsg = GetFtStatusDescription(ftStatus);
errormsg += ":FT_SetUSBParameters";
perror(errormsg.c_str());
oResult = false;
}
return oResult;
}
int main(int argc, char *argv[])
{
DWORD dwBytesInQueue = 0;
EVENT_HANDLE eh;
FT_STATUS ftStatus;
FT_HANDLE ftHandle;
int iport;
if(argc > 1) {
sscanf(argv[1], "%d", &iport);
}
else {
iport = 0;
}
pthread_mutex_init(&eh.eMutex, NULL);
pthread_cond_init(&eh.eCondVar, NULL);
ftStatus = FT_Open(iport, &ftHandle);
if(ftStatus != FT_OK) {
/*
This can fail if the ftdi_sio driver is loaded
use lsmod to check this and rmmod ftdi_sio to remove
also rmmod usbserial
*/
printf("FT_Open(%d) failed\n", iport);
return 1;
}
ftStatus = FT_SetFlowControl(ftHandle, FT_FLOW_NONE, 0, 0);
if(ftStatus != FT_OK) {
printf("Failed to set flow control\n");
}
ftStatus = FT_SetEventNotification(ftHandle, FT_EVENT_RXCHAR, (PVOID)&eh);
if(ftStatus != FT_OK) {
printf("Failed to set events\n");
return 1;
}
pthread_mutex_lock(&eh.eMutex);
pthread_cond_wait(&eh.eCondVar, &eh.eMutex);
pthread_mutex_unlock(&eh.eMutex);
FT_GetQueueStatus(ftHandle, &dwBytesInQueue);
printf("Received chars %d bytes in queue\n", (int)dwBytesInQueue);
FT_Close(ftHandle);
return 0;
}
int main(int argc, char *argv[])
{
char * pcBufRead;
DWORD dwBytesRead;
FILE * fh;
FT_HANDLE ftHandle;
FT_STATUS ftStatus;
int iport;
if(argc > 1) {
sscanf(argv[1], "%d", &iport);
}
else {
iport = 0;
}
fh = fopen("target.bin", "wb+");
if(fh == NULL) {
printf("Cant open source file\n");
return 1;
}
ftStatus = FT_Open(iport, &ftHandle);
if(ftStatus != FT_OK) {
/*
This can fail if the ftdi_sio driver is loaded
use lsmod to check this and rmmod ftdi_sio to remove
also rmmod usbserial
*/
printf("FT_Open(%d) failed\n", iport);
return 1;
}
pcBufRead = (char *)malloc(BUF_SIZE);
FT_ResetDevice(ftHandle);
FT_SetBaudRate(ftHandle, 115200);
FT_SetDtr(ftHandle);
FT_SetRts(ftHandle);
FT_SetFlowControl(ftHandle, FT_FLOW_RTS_CTS, 0, 0);
FT_SetTimeouts(ftHandle, 0, 0); // infinite timeouts
FT_SetBitMode(ftHandle, 0xFF, 0x01);
FT_Read(ftHandle, pcBufRead, BUF_SIZE, &dwBytesRead);
fwrite(pcBufRead, 1, dwBytesRead, fh);
fclose(fh);
free(pcBufRead);
FT_Close(ftHandle);
return 0;
}
/**
Open a power meter probe by a given serial number
\param pm a pointer to a pm_context
\param serial the serial number
\retval 0 - all fine
\retval -1 - open failed (wrong serial number?)
\retval -2 - setting baudrate failed
\retval -3 - setting data characteristics failed
\retval -4 - setting flow control failed
\retval -5 - setting timeouts failed
\retval -6 - purging buffers failed
\retval -7 - resetting device failed
*/
PM600X_EXPORT int pm_open(struct pm_context *pm, unsigned long serial)
{
FT_STATUS ftstat;
// convert the serial into a 8 digit string with leading zeroes
char serial_string[12];
snprintf(serial_string, 12, "%06lu", serial);
// open the device by a given serial number
ftstat = FT_OpenEx((void *)serial_string, FT_OPEN_BY_SERIAL_NUMBER, &pm->handle);
if (ftstat != FT_OK)
pm_error_return(-1, "open failed (wrong serial number?)");
// get the device info to obtain the power meter type
unsigned long id;
ftstat = FT_GetDeviceInfo(pm->handle, NULL, &id, NULL, NULL, NULL);
if (ftstat != FT_OK)
pm_error_return(-8, "can not retrieve device info!");
pm->type = id;
// set baud rate to 115200
ftstat = FT_SetBaudRate(pm->handle, FT_BAUD_115200);
if (ftstat != FT_OK)
pm_error_return(-2, "setting baudrate failed");
// set data characteristics to 8n1
ftstat = FT_SetDataCharacteristics(pm->handle, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE);
if (ftstat != FT_OK)
pm_error_return(-3, "setting data characteristics failed");
// set flow control to NONE
ftstat = FT_SetFlowControl(pm->handle, FT_FLOW_NONE, 0, 0);
if (ftstat != FT_OK)
pm_error_return(-4, "setting flow control failed");
// set timeouts to 1 second for writes and 3.5 seconds for reads. This should be enough when measuring with averaging == 10000
ftstat = FT_SetTimeouts(pm->handle, 3500, 1000);
if (ftstat != FT_OK)
pm_error_return(-5, "setting timeouts failed");
// purge bufffers just in case
ftstat = FT_Purge(pm->handle, FT_PURGE_RX | FT_PURGE_TX);
if (ftstat != FT_OK)
pm_error_return(-6, "purging buffers failed");
// reset the device via *RST
return pm_reset(pm);
}
bool CUsb3003DF2ETInterface::OpenDevice(void)
{
FT_STATUS ftStatus;
int baudrate = 921600;
//sets serial VID/PID for a Standard Device NOTE: This is for legacy purposes only. This can be ommitted.
ftStatus = FT_SetVIDPID(m_uiVid, m_uiPid);
if (ftStatus != FT_OK) {FTDI_Error((char *)"FT_SetVIDPID", ftStatus ); return false; }
ftStatus = FT_OpenEx((PVOID)m_szDeviceSerial, FT_OPEN_BY_SERIAL_NUMBER, &m_FtdiHandle);
if (ftStatus != FT_OK) { FTDI_Error((char *)"FT_OpenEx", ftStatus ); return false; }
CTimePoint::TaskSleepFor(50);
FT_Purge(m_FtdiHandle, FT_PURGE_RX | FT_PURGE_TX );
CTimePoint::TaskSleepFor(50);
ftStatus = FT_SetDataCharacteristics(m_FtdiHandle, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE);
if ( ftStatus != FT_OK ) { FTDI_Error((char *)"FT_SetDataCharacteristics", ftStatus ); return false; }
ftStatus = FT_SetFlowControl(m_FtdiHandle, FT_FLOW_RTS_CTS, 0x11, 0x13);
if (ftStatus != FT_OK) { FTDI_Error((char *)"FT_SetFlowControl", ftStatus ); return false; }
ftStatus = FT_SetRts (m_FtdiHandle);
if (ftStatus != FT_OK) { FTDI_Error((char *)"FT_SetRts", ftStatus ); return false; }
// for DF2ET-3003 interface pull DTR low to take AMBE3003 out of reset.
ftStatus = FT_SetDtr( m_FtdiHandle );
CTimePoint::TaskSleepFor(50);
if (ftStatus != FT_OK) { FTDI_Error((char *)"FT_SetDtr", ftStatus); return false; }
ftStatus = FT_SetBaudRate(m_FtdiHandle, baudrate );
if (ftStatus != FT_OK) { FTDI_Error((char *)"FT_SetBaudRate", ftStatus ); return false; }
ftStatus = FT_SetLatencyTimer(m_FtdiHandle, 4);
if (ftStatus != FT_OK) { FTDI_Error((char *)"FT_SetLatencyTimer", ftStatus ); return false; }
ftStatus = FT_SetUSBParameters(m_FtdiHandle, USB3XXX_MAXPACKETSIZE, 0);
if (ftStatus != FT_OK) { FTDI_Error((char *)"FT_SetUSBParameters", ftStatus ); return false; }
ftStatus = FT_SetTimeouts(m_FtdiHandle, 200, 200 );
if (ftStatus != FT_OK) { FTDI_Error((char *)"FT_SetTimeouts", ftStatus ); return false; }
// done
return true;
}
bool DYNA_initialize(FT_HANDLE ftHandleDYNA)
{
FT_STATUS ft_status;
ft_status = FT_ResetDevice(ftHandleDYNA);
if( ft_status != FT_OK )
goto DYNA_init_error;
ft_status = FT_SetDataCharacteristics(ftHandleDYNA, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE);
if( ft_status != FT_OK )
goto DYNA_init_error;
ft_status = FT_SetFlowControl(ftHandleDYNA, FT_FLOW_NONE, (UCHAR)0, (UCHAR)0);
if( ft_status != FT_OK )
goto DYNA_init_error;
ft_status = FT_SetLatencyTimer(ftHandleDYNA, LATENCY_TIME);
if( ft_status != FT_OK )
goto DYNA_init_error;
ft_status = FT_SetUSBParameters(ftHandleDYNA, IN_TRASFER_SIZE, 0);
if( ft_status != FT_OK )
goto DYNA_init_error;
ft_status = FT_SetTimeouts(ftHandleDYNA, 0, 0);
if( ft_status != FT_OK )
goto DYNA_init_error;
ft_status = FT_Purge(ftHandleDYNA, FT_PURGE_RX|FT_PURGE_TX);
if( ft_status != FT_OK )
goto DYNA_init_error;
ft_status = FT_SetBaudRate(ftHandleDYNA, 1000000);
if( ft_status != FT_OK )
goto DYNA_init_error;
return true;
DYNA_init_error:
qDebug() << "\n\nUSB2Dynamixel Initialization Error!";
FT_Close(ftHandleDYNA);
return false;
}
int dxl_hal_open()
{
FT_STATUS ft_status;
dxl_hal_close();
ft_status = FT_Open( 1, &ghFt_Handle );
if( ft_status != FT_OK )
goto DXL_HAL_OPEN_ERROR;
ft_status = FT_ResetDevice( ghFt_Handle );
if( ft_status != FT_OK )
goto DXL_HAL_OPEN_ERROR;
ft_status = FT_SetDataCharacteristics( ghFt_Handle, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE );
if( ft_status != FT_OK )
goto DXL_HAL_OPEN_ERROR;
ft_status = FT_SetFlowControl( ghFt_Handle, FT_FLOW_NONE, (UCHAR)0, (UCHAR)0 );
if( ft_status != FT_OK )
goto DXL_HAL_OPEN_ERROR;
ft_status = FT_SetLatencyTimer( ghFt_Handle, LATENCY_TIME );
if( ft_status != FT_OK )
goto DXL_HAL_OPEN_ERROR;
ft_status = FT_SetUSBParameters( ghFt_Handle, IN_TRASFER_SIZE, 0 );
if( ft_status != FT_OK )
goto DXL_HAL_OPEN_ERROR;
ft_status = FT_SetTimeouts( ghFt_Handle, 0, 0 );
if( ft_status != FT_OK )
goto DXL_HAL_OPEN_ERROR;
ft_status = FT_Purge( ghFt_Handle, FT_PURGE_RX|FT_PURGE_TX );
if( ft_status != FT_OK )
goto DXL_HAL_OPEN_ERROR;
return 1;
DXL_HAL_OPEN_ERROR:
dxl_hal_close();
return 0;
}
void
serial_init (char *port, int baud)
{
char *chipname;
switch (board_type)
{
case BT_powermeter:
chipname = "FT232R PowerMeter";
break;
case BT_powermeterproto:
chipname = "FT232R PowerMeter";
break;
default:
chipname = "FT232R - R8C";
break;
}
Fail (FT_OpenEx (chipname, FT_OPEN_BY_DESCRIPTION, &handle));
if (verbose > 2)
printf("handle: 0x%x\n", (int)handle);
atexit (serial_close);
ProgramMode (1);
Reset (1);
/* >3 mSec reset pulse */
usleep(3*1000);
Reset (0);
Fail (FT_SetBaudRate (handle, 9600));
Fail (FT_SetDataCharacteristics (handle, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE));
FT_SetFlowControl (handle, FT_FLOW_NONE, 0, 0);
/* 3 mSec delay to let board "wake up" after reset */
usleep(3*1000);
}
static void FTClassicPort_setFlowControl(FTClassicPort *self,USHORT FlowControl,UCHAR XonChar,UCHAR XoffChar){
self->status = FT_SetFlowControl(self->handle, FlowControl,
XonChar, XoffChar);
}
int main(int argc, char *argv[])
{
int retCode = -1; // Assume failure
int f = 0;
FT_STATUS ftStatus = FT_OK;
FT_HANDLE ftHandle = NULL;
int portNum = -1; // Deliberately invalid
DWORD bytesToWrite = 0;
DWORD bytesWritten = 0;
int inputRate = -1; // Entered on command line
int baudRate = 38400; // Rate to actually use
int rates[] = {50, 75, 110, 134, 150, 200,
300, 600, 1200, 1800, 2400, 4800,
9600, 19200, 38400, 57600, 115200,
230400, 460800, 576000, 921600};
if (argc > 1)
{
sscanf(argv[1], "%d", &portNum);
}
if (portNum < 0)
{
// Missing, or invalid. Just use first port.
portNum = 0;
}
if (portNum > 16)
{
// User probably specified a baud rate without a port number
printf("Syntax: %s [port number] [baud rate]\n", argv[0]);
portNum = 0;
}
if (argc > 2)
{
sscanf(argv[2], "%d", &inputRate);
for (f = 0; f < (int)(ARRAY_SIZE(rates)); f++)
{
if (inputRate == rates[f])
{
// User entered a rate we support, so we'll use it.
baudRate = inputRate;
break;
}
}
}
if (baudRate < 0)
baudRate = 9600;
printf("Trying FTDI device %d at %d baud.\n", portNum, baudRate);
ftStatus = FT_Open(portNum, &ftHandle);
if (ftStatus != FT_OK)
{
printf("FT_Open(%d) failed, with error %d.\n", portNum, (int)ftStatus);
printf("Use lsmod to check if ftdi_sio (and usbserial) are present.\n");
printf("If so, unload them using rmmod, as they conflict with ftd2xx.\n");
goto exit;
}
assert(ftHandle != NULL);
ftStatus = FT_ResetDevice(ftHandle);
if (ftStatus != FT_OK)
{
printf("Failure. FT_ResetDevice returned %d.\n", (int)ftStatus);
goto exit;
}
ftStatus = FT_SetBaudRate(ftHandle, (ULONG)baudRate);
if (ftStatus != FT_OK)
{
printf("Failure. FT_SetBaudRate(%d) returned %d.\n",
baudRate,
(int)ftStatus);
goto exit;
}
ftStatus = FT_SetDataCharacteristics(ftHandle,
FT_BITS_8,
FT_STOP_BITS_1,
FT_PARITY_NONE);
if (ftStatus != FT_OK)
{
printf("Failure. FT_SetDataCharacteristics returned %d.\n", (int)ftStatus);
goto exit;
}
// Indicate our presence to remote computer
ftStatus = FT_SetDtr(ftHandle);
if (ftStatus != FT_OK)
{
printf("Failure. FT_SetDtr returned %d.\n", (int)ftStatus);
goto exit;
}
// Flow control is needed for higher baud rates
ftStatus = FT_SetFlowControl(ftHandle, FT_FLOW_RTS_CTS, 0, 0);
if (ftStatus != FT_OK)
{
printf("Failure. FT_SetFlowControl returned %d.\n", (int)ftStatus);
goto exit;
}
// Assert Request-To-Send to prepare remote computer
ftStatus = FT_SetRts(ftHandle);
if (ftStatus != FT_OK)
{
printf("Failure. FT_SetRts returned %d.\n", (int)ftStatus);
goto exit;
}
ftStatus = FT_SetTimeouts(ftHandle, 3000, 3000); // 3 seconds
if (ftStatus != FT_OK)
{
printf("Failure. FT_SetTimeouts returned %d\n", (int)ftStatus);
goto exit;
}
bytesToWrite = (DWORD)(sizeof(testPattern) - 1); // Don't write string terminator
ftStatus = FT_Write(ftHandle,
testPattern,
bytesToWrite,
&bytesWritten);
if (ftStatus != FT_OK)
{
printf("Failure. FT_Write returned %d\n", (int)ftStatus);
goto exit;
}
if (bytesWritten != bytesToWrite)
{
printf("Failure. FT_Write wrote %d bytes instead of %d.\n",
(int)bytesWritten,
(int)bytesToWrite);
goto exit;
}
// Success
retCode = 0;
printf("Successfully wrote %d bytes\n", (int)bytesWritten);
exit:
if (ftHandle != NULL)
FT_Close(ftHandle);
return retCode;
}
void main(void)
{
void Delay(void); // Delay function
setvbuf(stdout,NULL,_IONBF,0); // Used to flush the IO buffers otherwise-
setvbuf(stderr,NULL,_IONBF,0); //-eclipse terminal will behave strangely
FT_HANDLE ft_handle; // Declaring the handle to the chip
FT_STATUS ft_status; // Variable for storing status of the operation
DWORD BaudRate; // Variable to hold the baud rate
char TxByte; // Variable to hold the byte to be tx'ed
DWORD NoOfBytesWritten = 0; // No of Bytes written to the port
UCHAR Mask; // for selecting which pins are input/output
UCHAR Mode; // Selects the mode of operation for the chip
int i = 1;
//------------------------------- Opening the Connection to the chip -----------------------------------//
ft_status = FT_Open(0,&ft_handle); // Opening a connection to the connected FT232RL chip
if(ft_status == FT_OK) // Error checking for FT_Open()
printf("Connection to the chip opened successfully\n");
else
printf("error in opening connection,Chip not connected or loose cable\n");
//--------------------------------------------------------------------------------------------------------//
//------------------------------- Setting the baud rate of the chip -------------------------------------//
BaudRate = 9600; // Set BaudRate = 9600
FT_SetBaudRate(ft_handle,BaudRate); // Setting the baudrate for the chip for 9600bps
if(ft_status == FT_OK) //Error checking for FT_SetBaudRate()
printf("Baud rate set to %d\n",BaudRate);
else
printf("Error in setting baud rate\n");
//--------------------------------------------------------------------------------------------------------//
//--------------------------- Setting Data bits,Stop bits,Parity Bits ------------------------------------//
ft_status = FT_SetDataCharacteristics( ft_handle, // Handle of the chip(FT232)
FT_BITS_8, // No of Data bits = 8
FT_STOP_BITS_1, // No of Stop Bits = 1
FT_PARITY_NONE // Parity = NONE
);
if(ft_status == FT_OK)
printf("Format-> 8 DataBits,No Parity,1 Stop Bit (8N1)\n");
else
printf("Error in setting Data Format \n");
//---------------- Setting Flow Control bits ------------------------------//
ft_status = FT_SetFlowControl( ft_handle, // Handle of the chip(FT232)
FT_FLOW_NONE, // No Flow control
NULL, // XON = Null since no Flow control
NULL // XOFF = Null since no Flow control
);
if(ft_status == FT_OK)
printf("Flow Control = None \n");
else
printf("Error in setting Flow Control \n");
//------------------------ Putting the Chip in CBUS bit Bang Mode ---------------------------------------//
Mode = 0x20; // Select Chip mode as CBUS Bit Bang
//--------------------------------------------------------------------------------------------------------------------------------//
// Calculating the Mask Value in CBUS Bit Bang Mode //
// //
// +------------------------------------------------------+ //
// |<------------------- Mask(8bit) --------------------->| Mask is an 8 bit Variable //
// +-----------------------+------+-----------------------+ //
// | Direction(4bits) | | Data (4bits) | Upper Nibble controls the Direction,LowerNibble controls data bits //
// +-----------------------+------+-----------------------+ //
// | 7 | 6 | 5 | 4 | | 3 | 2 | 1 | 0 | //
// +-----+-----+-----+-----+------+-----+-----+-----+-----+ //
// |CBUS3|CBUS2|CBUS1|CBUS0| |CBUS3|CBUS2|CBUS1|CBUS0| CBUS1 Connected to ~RE, CBUS2 Connected to DE //
// +-----+-----+-----+-----+------+-----+-----+-----+-----+ //
// | | | __ | | | | | __ | | __ //
// | x | DE | RE | x | | x | DE | RE | x | Data For TX,{ CBUS1 -> RE = High } and { CBUS2 -> DE = HIGH } //
// +-----+-----+-----+-----+------+-----+-----+-----+-----+ //
// | 0 | 1 | 1 | 0 | | 0 | 1 | 1 | 0 | Direction For TX,{ CBUS1->RE = Output } and { CBUS2->DE = Output } //
// +-----------------------+------+-----------------------+ //
// | 0x66 | //
// +------------------------------------------------------+ //
// //
//--------------------------------------------------------------------------------------------------------------------------------//
Mask = 0x66; //To activate the RE and DE signals for MAX485,
// ~RE -> High
// DE -> High
ft_status = FT_SetBitMode(ft_handle,Mask,Mode); // Opening Bit Bang Mode to put the chip in Transmit Mode
if(ft_status == FT_OK)
printf("Opening CBUS Bit Bang Mode successful\n");
else
printf("ERROR in Opening CBUS Bit Bang Mode\n");
//--------------------------------------------------------------------------------------------------------//
while(1)
{
//------------------------------- Writing a byte to serial port -----------------------------------------//
TxByte = 'A';
ft_status = FT_Write( ft_handle, // Handle to the chip
&TxByte, // Variable Containing the byte to be Txed
sizeof(TxByte), // sizeof(TxByte) = char
&NoOfBytesWritten // No of Bytes written to the port
);
if(ft_status == FT_OK) // Error checking for FT_Writee()
printf("%c written to the serial port at %d bps - [%d]\n",TxByte,BaudRate,i);
else
printf("Error in writing to port\n");
i++;
//--------------------------------------------------------------------------------------------------------//
Delay();
}
FT_Close(ft_handle); // Closing the handle to the chip
getch();
}
void main(void)
{
FT_HANDLE ft_handle; // Declaring the handle to the chip
FT_STATUS ft_status; // Variable for storing status of the operation
DWORD BaudRate; // Variable to hold the baud rate
char TxByte; // Variable to hold the byte to be tx'ed
DWORD NoOfBytesWritten = 0; // No of Bytes written to the port
//------------------------------- Opening the Connection to the chip -----------------------------------//
ft_status = FT_Open(0,&ft_handle); // Opening a connection to the connected FT232RL chip
if(ft_status == FT_OK) // Error checking for FT_Open()
printf("\n\n\tConnection to the chip opened successfully\n");
else
printf("\terror in opening connection,Chip not connected or loose cable\n");
//--------------------------------------------------------------------------------------------------------//
//------------------------------- Setting the baud rate of the chip -------------------------------------//
BaudRate = 9600; // Set BaudRate = 9600
FT_SetBaudRate(ft_handle,BaudRate); // Setting the baudrate for the chip for 9600bps
if(ft_status == FT_OK) //Error checking for FT_SetBaudRate()
printf("\tBaud rate set to %d\n",BaudRate);
else
printf("\tError in setting baud rate\n");
//--------------------------- Setting Data bits,Stop bits,Parity Bits ------------------------------------//
ft_status = FT_SetDataCharacteristics( ft_handle, // Handle of the chip(FT232)
FT_BITS_8, // No of Data bits = 8
FT_STOP_BITS_1, // No of Stop Bits = 1
FT_PARITY_NONE // Parity = NONE
);
if(ft_status == FT_OK)
printf("\tFormat-> 8 DataBits,No Parity,1 Stop Bit (8N1)\n");
else
printf("\tError in setting Data Format \n");
//--------------------------------- Setting Flow Control bits -------------------------------------------//
ft_status = FT_SetFlowControl( ft_handle, // Handle of the chip(FT232)
FT_FLOW_NONE, // No Flow control
NULL, // XON = Null since no Flow control
NULL // XOFF = Null since no Flow control
);
if(ft_status == FT_OK)
printf("\tFlow Control = None \n");
else
printf("\tError in setting Flow Control \n");
//------------------------------- Writing a byte to serial port -----------------------------------------//
TxByte = 'A';
ft_status = FT_Write( ft_handle, // Handle to the chip
&TxByte, // Variable Containing the byte to be Txed
sizeof(TxByte), // sizeof(TxByte) = char
&NoOfBytesWritten // No of Bytes written to the port
);
if(ft_status == FT_OK) // Error checking for FT_Writee()
printf("\t'%c' written to the serial port at %d bps\n",TxByte,BaudRate);
else
printf("\tError in writing to port\n");
//--------------------------------------------------------------------------------------------------------//
FT_Close(ft_handle); // Closing the handle to the chip
getch();
}
int main(int argc, char **argv) {
FILE *fd;
FT_STATUS ftStatus = FT_OK;
FT_HANDLE ftHandle;
DWORD dwNumberOfDevices = 0;
// int vid = 0x0403, pid = 0x6001;
// int vid = 0x1781, pid = 0x0C31;
int vid = 0x1781, pid = 0x0C30;
if (argc < 2) {
printf("Usage: %s filename\n", argv[0]);
return 1;
}
FT_SetVIDPID(vid, pid);
fd = fopen(argv[1], "r");
if (!fd) {
fclose(fd);
printf("Could not open file\n");
return 1;
}
ftStatus = FT_CreateDeviceInfoList(&dwNumberOfDevices);
if (ftStatus == FT_OK) {
bool found = false;
for (int i = 0; i < (int)dwNumberOfDevices; i++) {
FT_PROGRAM_DATA pData;
char ManufacturerBuf[32];
char ManufacturerIdBuf[16];
char DescriptionBuf[64];
char SerialNumberBuf[16];
pData.Signature1 = 0x00000000;
pData.Signature2 = 0xffffffff;
pData.Version = 0x00000002; // EEPROM structure with FT232R extensions
pData.Manufacturer = ManufacturerBuf;
pData.ManufacturerId = ManufacturerIdBuf;
pData.Description = DescriptionBuf;
pData.SerialNumber = SerialNumberBuf;
ftStatus = FT_Open(i, &ftHandle);
ftStatus = FT_EE_Read(ftHandle, &pData);
if(ftStatus == FT_OK){
if(pData.VendorId == vid && pData.ProductId == pid){
found = true;
break;
}
}
FT_Close(ftHandle);
}
if (!found) {
printf("Could not find TellStick (Duo)\n");
return 1;
}
}
if (pid == 0x0C31) {
FT_SetBaudRate(ftHandle, 115200);
} else {
FT_SetBaudRate(ftHandle, 9600);
}
FT_SetFlowControl(ftHandle, FT_FLOW_NONE, 0, 0);
std::string data = readHex(fd);
FT_Purge(ftHandle, FT_PURGE_RX | FT_PURGE_TX);
printf("Reboot TellStick...");
ftStatus = FT_SetBitMode(ftHandle, 0xff, 0x20);
sleep(1);
printf("Done\n");
ftStatus = FT_SetBitMode(ftHandle, 0xf0, 0x20);
printf("Waiting for TellStick Duo Bootloader.\n");
waitFor(ftHandle, 'g');
send(ftHandle, 'r');
printf("Uploading hex-file\n");
uploadHex(ftHandle, data);
printf("Rebooting TellStick\n");
waitFor(ftHandle, 'b');
send(ftHandle, 0x00);
printf("Firmware updated!\n");
FT_Close(ftHandle);
fclose(fd);
}
int main(int argc, char *argv[])
{
int retCode = -1; // Assume failure
int f = 0;
DWORD driverVersion = 0;
FT_STATUS ftStatus = FT_OK;
FT_HANDLE ftHandle = NULL;
int portNum = 0; // First device found
size_t bufferSize = 64 * 1024;
DWORD bytesToWrite;
DWORD bytesWritten = 0;
DWORD bytesReceived = 0;
DWORD bytesRead = 0;
struct timeval startTime;
int journeyDuration;
unsigned char *writeBuffer = NULL;
unsigned char *readBuffer = NULL;
int queueChecks = 0;
ULONG rates[] = {300, 600, 1200, 2400, 4800, 9600,
19200, 38400, 57600, 115200,
230400, 460800, 576000, 921600,
1500000, 2000000, 3000000};
// TODO: detect high-speed device and use 8240000
UNUSED_PARAMETER(argc);
UNUSED_PARAMETER(argv);
// Make printfs immediate (no buffer)
setvbuf(stdout, NULL, _IONBF, 0);
writeBuffer = (unsigned char *)malloc((size_t)bufferSize);
if (writeBuffer == NULL)
goto exit;
// Fill write buffer with consecutive values
for (f = 0; f < (int)bufferSize; f++)
{
writeBuffer[f] = (unsigned char)f + 64;
}
printf("Opening FTDI device %d.\n", portNum);
ftStatus = FT_Open(portNum, &ftHandle);
if (ftStatus != FT_OK)
{
printf("FT_Open(%d) failed, with error %d.\n", portNum, (int)ftStatus);
printf("On Linux, lsmod can check if ftdi_sio (and usbserial) are present.\n");
printf("If so, unload them using rmmod, as they conflict with ftd2xx.\n");
goto exit;
}
assert(ftHandle != NULL);
ftStatus = FT_GetDriverVersion(ftHandle, &driverVersion);
if (ftStatus != FT_OK)
{
printf("Failure. FT_GetDriverVersion returned %d.\n",
(int)ftStatus);
goto exit;
}
printf("Using D2XX version %08x\n", driverVersion);
ftStatus = FT_ResetDevice(ftHandle);
if (ftStatus != FT_OK)
{
printf("Failure. FT_ResetDevice returned %d.\n", (int)ftStatus);
goto exit;
}
// Flow control is needed for higher baud rates
ftStatus = FT_SetFlowControl(ftHandle, FT_FLOW_RTS_CTS, 0, 0);
if (ftStatus != FT_OK)
{
printf("Failure. FT_SetFlowControl returned %d.\n", (int)ftStatus);
goto exit;
}
ftStatus = FT_SetDataCharacteristics(ftHandle,
FT_BITS_8,
FT_STOP_BITS_1,
FT_PARITY_NONE);
if (ftStatus != FT_OK)
{
printf("Failure. FT_SetDataCharacteristics returned %d.\n",
(int)ftStatus);
goto exit;
}
for (f = 0; f < (int)ARRAY_SIZE(rates); f++)
{
ftStatus = FT_SetBaudRate(ftHandle, rates[f]);
if (ftStatus != FT_OK)
{
printf("Failure. FT_SetBaudRate(%d) returned %d.\n",
(int)rates[f],
(int)ftStatus);
goto exit;
}
// Assert Request-To-Send to prepare receiver
ftStatus = FT_SetRts(ftHandle);
if (ftStatus != FT_OK)
{
printf("Failure. FT_SetRts returned %d.\n", (int)ftStatus);
goto exit;
}
if (rates[f] < 57600)
{
// Keep test duration reasonable by transferring fewer
// bytes at low baud rates.
bytesToWrite = rates[f] / 4;
}
else
{
bytesToWrite = bufferSize;
}
printf("\nBaud rate %d. Writing %d bytes to loopback device...\n",
(int)rates[f],
(int)bytesToWrite);
ftStatus = FT_Write(ftHandle,
writeBuffer,
bytesToWrite,
&bytesWritten);
if (ftStatus != FT_OK)
{
printf("Failure. FT_Write returned %d\n", (int)ftStatus);
goto exit;
}
if (bytesWritten != bytesToWrite)
{
printf("Failure. FT_Write wrote %d bytes instead of %d.\n",
(int)bytesWritten,
(int)bytesToWrite);
goto exit;
}
printf("%d bytes written.\n", (int)bytesWritten);
// Keep checking queue until D2XX has received all the bytes we wrote.
// Estimate total time to write and read, so we can time-out.
// Each byte has 8 data bits plus a stop bit and perhaps a 1-bit gap.
journeyDuration = bytesWritten * (8 + 1 + 1) / (int)rates[f];
journeyDuration += 1; // Round up
journeyDuration *= 2; // It's a return journey
printf("Estimate %d seconds remain.\n", journeyDuration);
gettimeofday(&startTime, NULL);
for (bytesReceived = 0, queueChecks = 0;
bytesReceived < bytesWritten;
queueChecks++)
{
// Periodically check for time-out
if (queueChecks % 32 == 0)
{
struct timeval now;
struct timeval elapsed;
gettimeofday(&now, NULL);
timersub(&now, &startTime, &elapsed);
if (elapsed.tv_sec > (long int)journeyDuration)
{
// We've waited too long. Give up.
printf("\nTimed out after %ld seconds\n", elapsed.tv_sec);
break;
}
// Display number of bytes D2XX has received
printf("%s%d",
queueChecks == 0 ? "Number of bytes in D2XX receive-queue: " : ", ",
(int)bytesReceived);
}
ftStatus = FT_GetQueueStatus(ftHandle, &bytesReceived);
if (ftStatus != FT_OK)
{
printf("\nFailure. FT_GetQueueStatus returned %d.\n",
(int)ftStatus);
goto exit;
}
}
printf("\nGot %d (of %d) bytes.\n", (int)bytesReceived, (int)bytesWritten);
// Even if D2XX has the wrong number of bytes, create our
// own buffer so we can read and display them.
free(readBuffer); // Free previous iteration's buffer.
readBuffer = (unsigned char *)calloc(bytesReceived, sizeof(unsigned char));
if (readBuffer == NULL)
{
printf("Failed to allocate %d bytes.\n", bytesReceived);
goto exit;
}
// Then copy D2XX's buffer to ours.
ftStatus = FT_Read(ftHandle, readBuffer, bytesReceived, &bytesRead);
if (ftStatus != FT_OK)
{
printf("Failure. FT_Read returned %d.\n", (int)ftStatus);
goto exit;
}
if (bytesRead != bytesReceived)
{
printf("Failure. FT_Read only read %d (of %d) bytes.\n",
(int)bytesRead,
(int)bytesReceived);
goto exit;
}
if (0 != memcmp(writeBuffer, readBuffer, bytesRead))
{
printf("Failure. Read-buffer does not match write-buffer.\n");
printf("Write buffer:\n");
dumpBuffer(writeBuffer, bytesReceived);
printf("Read buffer:\n");
dumpBuffer(readBuffer, bytesReceived);
goto exit;
}
// Fail if D2XX's queue lacked (or had surplus) bytes.
if (bytesReceived != bytesWritten)
{
printf("Failure. D2XX received %d bytes but we expected %d.\n",
(int)bytesReceived,
(int)bytesWritten);
dumpBuffer(readBuffer, bytesReceived);
goto exit;
}
// Check that queue hasn't gathered any additional unexpected bytes
bytesReceived = 4242; // deliberately junk
ftStatus = FT_GetQueueStatus(ftHandle, &bytesReceived);
if (ftStatus != FT_OK)
{
printf("Failure. FT_GetQueueStatus returned %d.\n",
(int)ftStatus);
goto exit;
}
if (bytesReceived != 0)
{
printf("Failure. %d bytes in input queue -- expected none.\n",
(int)bytesReceived);
goto exit;
}
}
// Success
printf("\nTest PASSED.\n");
retCode = 0;
exit:
free(readBuffer);
free(writeBuffer);
if (ftHandle != NULL)
FT_Close(ftHandle);
return retCode;
}
int main(int argc, char* argv[])
{
FT_HANDLE fthandle;
FT_STATUS status;
DWORD numdev = 0;
// Open the first device connected to the system (which has index 0). You can use the various other
// functions such as open_by_description to make this much more flexible and user friendly to let the user
// choose which device to open. See the D2xx Programmers Guide for more information
// Check how many FTDI devices are connected and installed. If one or more connected, open the first one
status = FT_CreateDeviceInfoList(&numdev);
if ((status == FT_OK) && (numdev > 0) )
{
// Open the device now
status = FT_Open(0, &fthandle);
if(status != FT_OK)
printf("status not ok %d\n", status);
// Set the In transfer size. You can set up to 64K if required. Ideally, use a small value like this for
// receiving a few bytes at a time or a larger value if you will be transferring large amounts of data
status = FT_SetUSBParameters(fthandle, 256, 0);
if(status != FT_OK)
printf("status not ok %d\n", status);
// Reset the device
status = FT_ResetDevice(fthandle);
if(status != FT_OK)
printf("status not ok %d\n", status);
// Set the handshaking mode in the driver, for I2C chips this has no affect on the external I2C interface
// since it does not have handshake lines but this enables internal handshake in the driver
status = FT_SetFlowControl(fthandle, FT_FLOW_RTS_CTS, FT_STOP_BITS_1, FT_PARITY_NONE);
if(status != FT_OK)
printf("status not ok %d\n", status);
// Set Timeouts to ensure a Read or Write will return if unable to be completed
// Setting both read and write timeouts to 5 seconds
status = FT_SetTimeouts(fthandle, 5000, 5000);
if(status != FT_OK)
printf("status not ok %d\n", status);
// Set Latency Timer (keeping it at default of 16ms here)
status = FT_SetLatencyTimer(fthandle, 16);
if(status != FT_OK)
printf("status not ok %d\n", status);
// Now write some data to the chips buffer
char data_out[12] = "HELLO WORLD";
DWORD w_data_len = 12;
DWORD data_written;
status = FT_Write(fthandle, data_out, w_data_len, &data_written);
if(status != FT_OK)
printf("status not ok %d\n", status);
else
printf("12 Bytes Sent, waiting for bytes to come back\n");
/**********************************************************************/
// The I2C Master should now be able to read these 12 bytes from the FT-X over I2C. This example expects the
// I2C Master to send the bytes back over I2C to the FT-X
/**********************************************************************/
// Now read the data which the I2C master has written to the FT-X
char data_in[12];
DWORD data_read;
DWORD MyBytesReceived = 0;
DWORD SoftwareTimeout = 0;
// Wait for the FT-X to send our 12 bytes back to the PC
while((MyBytesReceived <12) && (SoftwareTimeout < 500))
{
FT_GetQueueStatus(fthandle, &MyBytesReceived);
Sleep(1);
SoftwareTimeout ++;
}
// Check if the loop exited due to timing out or receiving 12 bytes
if(SoftwareTimeout == 500)
{
printf("Timed out waiting for data\n");
}
else
{
// Now read the received bytes
status = FT_Read(fthandle, data_in, MyBytesReceived, &data_read);
if(status != FT_OK)
printf("status not ok %d\n", status);
else
printf("data read %s\n", data_in);
}
// Close the device
status = FT_Close(fthandle);
}
else
{
printf("No FTDI devices connected to the computer \n");
}
printf("Press Return To End Program");
getchar();
printf("closed \n");
return 0;
}
int ftdi_init()
{
FT_DEVICE ftDevice;
DWORD deviceID;
char SerialNumber[16+1];
char Description[64+1];
// Does an FTDI device exist?
printf("Checking for FTDI devices...\n");
ftStatus = FT_CreateDeviceInfoList(&dwNumDevs);
// Get the number of FTDI devices
if (ftStatus != FT_OK) // Did the command execute OK?
{
printf("Error in getting the number of devices\n");
return 1; // Exit with error
}
if (dwNumDevs < 1) // Exit if we don't see any
{
printf("There are no FTDI devices installed\n");
return 1; // Exist with error
}
printf("%d FTDI devices found - the count includes individual ports on a single chip\n", dwNumDevs);
ftHandle=NULL;
//go thru' list of devices
for(int i=0; i<dwNumDevs; i++)
{
printf("Open port %d\n",i);
ftStatus = FT_Open(i, &ftHandle);
if (ftStatus != FT_OK)
{
printf("Open Failed with error %d\n", ftStatus);
printf("If runing on Linux then try <rmmod ftdi_sio> first\n");
continue;
}
FT_PROGRAM_DATA ftData;
char ManufacturerBuf[32];
char ManufacturerIdBuf[16];
char DescriptionBuf[64];
char SerialNumberBuf[16];
ftData.Signature1 = 0x00000000;
ftData.Signature2 = 0xffffffff;
ftData.Version = 0x00000003; //3 = FT2232H extensions
ftData.Manufacturer = ManufacturerBuf;
ftData.ManufacturerId = ManufacturerIdBuf;
ftData.Description = DescriptionBuf;
ftData.SerialNumber = SerialNumberBuf;
ftStatus = FT_EE_Read(ftHandle,&ftData);
if (ftStatus == FT_OK)
{
printf("\tDevice: %s\n\tSerial: %s\n", ftData.Description, ftData.SerialNumber);
printf("\tDevice Type: %02X\n", ftData.IFAIsFifo7 );
break;
}
else
{
printf("\tCannot read ext flash\n");
}
}
if(ftHandle==NULL)
{
printf("NO FTDI chip with FIFO function\n");
return -1;
}
//ENABLE SYNC FIFO MODE
ftStatus |= FT_SetBitMode(ftHandle, 0xFF, 0x00);
ftStatus |= FT_SetBitMode(ftHandle, 0xFF, 0x40);
if (ftStatus != FT_OK)
{
printf("Error in initializing1 %d\n", ftStatus);
FT_Close(ftHandle);
return 1; // Exit with error
}
UCHAR LatencyTimer = 2; //our default setting is 2
ftStatus |= FT_SetLatencyTimer(ftHandle, LatencyTimer);
ftStatus |= FT_SetUSBParameters(ftHandle,0x10000,0x10000);
ftStatus |= FT_SetFlowControl(ftHandle,FT_FLOW_RTS_CTS,0x10,0x13);
if (ftStatus != FT_OK)
{
printf("Error in initializing2 %d\n", ftStatus);
FT_Close(ftHandle);
return 1; // Exit with error
}
//return with success
return 0;
}
int nifalcon_load_firmware(falcon_device* dev, const char* firmware_filename)
{
unsigned long bytes_written;
unsigned char check_msg_1[3] = {0x0a, 0x43, 0x0d};
unsigned char check_msg_2[1] = "A";
unsigned char send_buf[128], receive_buf[128];
FILE* firmware_file;
if(!dev->is_open) nifalcon_error_return(NIFALCON_DEVICE_NOT_FOUND_ERROR, "tried load firmware to an unopened device");
if((dev->falcon_status_code = FT_ResetDevice(dev->falcon)) != FT_OK) return -dev->falcon_status_code;
//Set to:
// 9600 baud
// 8n1
// No Flow Control
// RTS Low
// DTR High
if((dev->falcon_status_code = FT_SetBaudRate(dev->falcon, 9600)) != FT_OK) return -dev->falcon_status_code;
if((dev->falcon_status_code = FT_SetDataCharacteristics(dev->falcon, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE)) != FT_OK) return -dev->falcon_status_code;
if((dev->falcon_status_code = FT_SetFlowControl(dev->falcon, FT_FLOW_NONE, 0, 0)) != FT_OK) return -dev->falcon_status_code;
if((dev->falcon_status_code = FT_ClrRts(dev->falcon)) != FT_OK) return -dev->falcon_status_code;
if((dev->falcon_status_code = FT_ClrDtr(dev->falcon)) != FT_OK) return -dev->falcon_status_code;
if((dev->falcon_status_code = FT_SetDtr(dev->falcon)) != FT_OK) return -dev->falcon_status_code;
//Send 3 bytes: 0x0a 0x43 0x0d
if((dev->falcon_status_code = nifalcon_write(dev, check_msg_1, 3)) < 3) return -dev->falcon_status_code;
//Expect 5 bytes back
if((dev->falcon_status_code = nifalcon_read(dev, receive_buf, 5, 1000)) < 5) return -dev->falcon_status_code;
//Set to:
// DTR Low
// 140000 baud (0x15 clock ticks per signal)
if((dev->falcon_status_code = FT_ClrDtr(dev->falcon)) != FT_OK) return -dev->falcon_status_code;
if((dev->falcon_status_code = FT_SetBaudRate(dev->falcon, 140000)) != FT_OK) return -dev->falcon_status_code;
//Send "A" character
if((dev->falcon_status_code = nifalcon_write(dev, check_msg_2, 1)) < 0) return -dev->falcon_status_code;
//Expect back 2 bytes:
// 0x13 0x41
if((dev->falcon_status_code = nifalcon_read(dev, receive_buf, 2, 1000)) < 0) return -dev->falcon_status_code;
firmware_file = fopen(firmware_filename, "rb");
if(!firmware_file)
{
nifalcon_error_return(NIFALCON_FIRMWARE_NOT_FOUND_ERROR, "cannot find falcon firmware file");
}
while(!feof(firmware_file))
{
int firmware_bytes_read;
int i;
firmware_bytes_read = fread(send_buf, 1, 128, firmware_file);
if((dev->falcon_status_code = nifalcon_write(dev, send_buf, firmware_bytes_read)) < 0) return dev->falcon_status_code;
if((dev->falcon_status_code = nifalcon_read(dev, receive_buf, firmware_bytes_read, 1000)) < 0) return dev->falcon_status_code;
if(firmware_bytes_read < 128) break;
}
fclose(firmware_file);
if((dev->falcon_status_code = FT_SetBaudRate(dev->falcon, 1456312)) != FT_OK) return -dev->falcon_status_code;
return FT_OK;
}
bool FTDIDMXDevice::open()
{
// Change QString to char* (not const char* note)
char *serial;
QByteArray a = m_path.toLatin1();
serial = (char*)malloc(sizeof(char) * (a.count() + 1));
memcpy(serial, a.constData(), a.count());
serial[a.count()] = 0;
#ifndef WIN32
// Windows users cannot dynamiccaly set VID/PID of harward
if (FT_SetVIDPID(m_vid, m_pid) == FT_OK &&
FT_OpenEx(serial, FT_OPEN_BY_SERIAL_NUMBER, &m_handle) == FT_OK)
{
#else
if (FT_OpenEx(serial, FT_OPEN_BY_SERIAL_NUMBER, &m_handle) == FT_OK)
{
#endif
free(serial);
if (!FT_SUCCESS(FT_ResetDevice(m_handle)))
{
qWarning() << "Unable to reset FTDI device" << m_path;
return false;
}
// Set the baud rate 12 will give us 250Kbits
if (!FT_SUCCESS(FT_SetDivisor(m_handle, 12)))
{
qWarning() << "Unable to set divisor on FTDI device"
<< m_path;
return false;
}
// Set the data characteristics
if (!FT_SUCCESS(FT_SetDataCharacteristics(m_handle,
FT_BITS_8,
FT_STOP_BITS_2,
FT_PARITY_NONE)))
{
qWarning() << "Unable to set data characteristics on"
<< "FTDI device" << m_path;
return false;
}
// Set flow control
if (!FT_SUCCESS(FT_SetFlowControl(m_handle, FT_FLOW_NONE, 0, 0)))
{
qWarning() << "Unable to set flow control on"
<< "FTDI device" << m_path;
return false;
}
// set RS485 for sendin
FT_ClrRts(m_handle);
// Clear TX RX buffers
FT_Purge(m_handle,FT_PURGE_TX | FT_PURGE_RX);
m_threadRunning = true;
start(QThread::TimeCriticalPriority);
return true;
}
else
{
qWarning() << "Unable to open FTDIDMX"
<< m_output << ":" << serial;
free(serial);
return false;
}
}
bool FTDIDMXDevice::close()
{
// Kill thread
m_threadRunning = false;
wait(500);
FT_Close(m_handle);
return true;
}
