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())); }
FT_STATUS OpenDevice(DeviceParams_t* device) { FT_STATUS status; FT_SetVIDPID(device->vid, device->pid); status = FT_OpenEx((PVOID) device->serial, FT_OPEN_BY_SERIAL_NUMBER, &(device->handle)); if(status == FT_OK) { status = FT_SetDataCharacteristics(device->handle, FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE); } if(status == FT_OK) { status = FT_SetBaudRate(device->handle, device->baud); } if(status == FT_OK) { // pthread_mutex_init(&device->rxEvent.eMutex, NULL); // pthread_cond_init(&device->rxEvent.eCondVar, NULL); // status = FT_SetEventNotification(device->handle, FT_EVENT_RXCHAR, (PVOID) &(device->rxEvent)); // pthread_create(&(device->thread), NULL, ReadData, (void*)device); } printf ("Open state [%x]\r\n", status); return status; }
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; }
static void ft245r_set_bitclock(PROGRAMMER * pgm) { FT_STATUS r; int rate = 0; int i; if (pgm->bitclock == 0.0) { // using default rate = 235000.0 /2; } else if (pgm->bitclock >= 0.50 ) { rate = 500000.0 /2; } else if (pgm->bitclock < 0.01) { rate = 1000.0 /2; } else { rate = pgm->bitclock * 1000000.0 /2; } for (i= sizeof(valid_rates)/sizeof(valid_rates[0]) -1; i>=0; --i) { if (valid_rates[i] <= rate) { rate = valid_rates[i]; break; } } if (i<0) rate = valid_rates[0]; r = FT_SetBaudRate(handle, rate); if ((verbose>=1) || FT245R_DEBUG) { fprintf(stderr," ft245r: bitclk %d -> ft baud %d\n", rate * 2, rate); } }
/* * 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; }
bool FTDXXDevice::connect (int baudrate) throw () { #ifdef FOUND_ftd2xx disconnect(); _status = FT_SetVIDPID(0x0403, 0x6001); FXXCHECK("Could not set IDs."); _status = FT_Open(0, &_handle); FXXCHECK("Could not open handle."); _status = FT_SetBaudRate(_handle, baudrate); FXXCHECK("Could not set baudrate."); _status = FT_SetLatencyTimer(_handle, 0); FXXCHECK("Unable to set latency timer."); _status = FT_Purge(_handle, FT_PURGE_RX | FT_PURGE_TX); FXXCHECK("Unable to purge buffers."); _initialized = true; FTDLOG("Connection successful."); return true; #else _initialized = false; FTDERROR("cannot connect FTD2xx device: compiled without required libraries"); return false; #endif }
bool FtdiDevices::setSpeed( ULONG baudRate ) { FT_STATUS ftStatus; ftStatus = FT_SetBaudRate(m_ftHandleA, baudRate); if (!FT_SUCCESS(ftStatus)) { return false; } return true; }
FT_STATUS FTDISerial::Connect(DWORD baudRate) { FT_STATUS status; status = FT_OpenEx("Nova Power Input Module", FT_OPEN_BY_DESCRIPTION, &m_handle); if(status == FT_OK) { m_isConnected = true; FT_SetBaudRate(m_handle, baudRate); } return status; }
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 D2xxSerial::setBaudRate(int baudRate) { FT_STATUS err = FT_SetBaudRate(handle, baudRate); if(err!=FT_OK) { printf("Error setting baud rate: %s\n", getError(err)); return false; } //printf("%d baud rate\n", baudRate); return true; }
int dxl_hal_set_baud( float baudrate ) { FT_STATUS ft_status; int iBaudrate; iBaudrate = (int)baudrate; ft_status = FT_SetBaudRate( ghFt_Handle, (DWORD)iBaudrate ); if( ft_status != FT_OK ) return 0; gfByteTransTime = (float)((1000.0f / baudrate) * 12.0f); return 1; }
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); }
int main(int argc, char *argv[]) { DWORD dwBytesInQueue = 0; FT_STATUS ftStatus; FT_HANDLE ftHandle; unsigned char ucMode = 0x00; int iport; if(argc > 1) { sscanf(argv[1], "%d", &iport); } else { iport = 0; } 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_SetBitMode(ftHandle, 0xFF, 1); if(ftStatus != FT_OK) { printf("Failed to set bit mode\n"); } FT_SetBaudRate(ftHandle, 9600); FT_Write(ftHandle, &ucMode, 1, &dwBytesInQueue); ftStatus = FT_GetBitMode(ftHandle, &ucMode); if(ftStatus != FT_OK) { printf("Failed to get bit mode\n"); } else { printf("ucMode = 0x%X\n", ucMode); } FT_Close(ftHandle); return 0; }
BOOL InitializeForBitIO(void) { DWORD DeviceCount; FT_Status = FT_CreateDeviceInfoList(&DeviceCount); if (FT_Status) return printf("FT_CreateDeviceInfoList failed (%d)", FT_Status); if (DeviceCount == 0) return printf("No FTDI devices attached\n"); FT_Status = FT_Open(0, &FT_Handle); if (FT_Status) return printf("FT_Open failed (%d)", FT_Status); FT_Status = FT_SetBaudRate(FT_Handle, 921600); if (FT_Status) return printf("FT_SetBaudRate failed (%d)", FT_Status); FT_Status = FT_SetBitMode(FT_Handle, 1, SyncBitBang); if (FT_Status) return printf("FT_SetBitMode failed (%d)", FT_Status); return 0; }
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; }
bool CMmcUsbHndlBase::SetBaudrate(unsigned int ulBaudrate) { if( !AreLibraryFunctionsLoaded() ) { perror("Library not loaded"); return false; } FT_STATUS ftStatus = FT_SetBaudRate(m_Handle, ulBaudrate); if( ftStatus != FT_OK ) { std::string errormsg = GetFtStatusDescription(ftStatus); errormsg += ":FT_GetStatus"; perror(errormsg.c_str()); } return (FT_OK == ftStatus); }
/* SET PARAMETR USB*/ quint16 ftdiChip::setParametersUSB(quint64 Speed, quint8 DataBit, quint8 StopBit, quint8 Parity) { FT_STATUS ftStatus; ftStatus=FT_SetBaudRate(hdUSB,Speed); if (ftStatus){ emit signalStatusError(tr("Error setting parameters <speed FTDI>"),true); return retErr; } parameter.setSpeed(Speed); ftStatus=FT_SetDataCharacteristics(hdUSB,(UCHAR)DataBit,(UCHAR)StopBit,(UCHAR)Parity); if (ftStatus!=FT_OK){ emit signalStatusError(tr("Error setting parameters <databit FTDI>"),true); return retErr; } parameter.setDataBit(DataBit); parameter.setStopBit(StopBit); parameter.setParity(Parity); emit signalStatusOk(tr("Parameters is successful!")); return retOk; }
int main() { int i,n; unsigned char data[255 * 256]; FT_HANDLE handle; DWORD bytes; /* Generate data for a single PWM 'throb' cycle */ memset(data, 0, sizeof(data)); for(i=1; i<128; i++) { /* Apply gamma correction to PWM brightness */ n = (int)(pow((double)i / 127.0, 2.5) * 255.0); memset(&data[i * 255], LED1, n); /* Ramp up */ memset(&data[(256 - i) * 255], LED1, n); /* Ramp down */ } /* Copy data from first LED to others, offset as appropriate */ n = sizeof(data) / 4; for(i=0; i<sizeof(data); i++) { if(data[i] & LED1) { data[(i + n ) % sizeof(data)] |= LED2; data[(i + n * 2) % sizeof(data)] |= LED3; data[(i + n * 3) % sizeof(data)] |= LED4; } } /* Initialize, open device, set bitbang mode w/5 outputs */ if(FT_Open(0, &handle) != FT_OK) { puts("Can't open device"); return 1; } FT_SetBitMode(handle, LED1 | LED2 | LED3 | LED4, 1); FT_SetBaudRate(handle, 9600); /* Actually 9600 * 16 */ /* Endless loop: dump precomputed PWM data to the device */ for(;;) FT_Write(handle, &data, (DWORD)sizeof(data), &bytes); }
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); }
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 serial_change_baud (int baud) { Fail (FT_SetBaudRate (handle, baud)); }
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(); }
/* This internal function handles the actual FTDI init and memory alloc for the library, with graceful cleanup in all error cases. Keeps subsequent TCopen() function simpler with regards to error handling. */ static TCstatusCode openAlloc( unsigned char s, /* Number of strands */ int p) /* Number of pixels in longest strand */ { /* Parameter validation was already done in TCopen(). */ /* Function works from a presumed error condition progressing toward success. This makes the cleanup cases easier. */ TCstatusCode status = TC_ERR_MALLOC; /* Size of pixelOutBuffer depends whether the serial clock is provided by one of the CBUS pins or must be bit-banged via software. If using 8 strands, MUST use CBUS clock. */ if(s >= TC_CBUS_CLOCK) { bytesPerPixel = 32; if(s > TC_CBUS_CLOCK) s -= TC_CBUS_CLOCK; } else { bytesPerPixel = 64; } /* All library memory use is handled in one big malloc. The data types are sorted to avoid alignment issues. pixelOutBuffer includes latch data at end. */ if((pixelCurrent = (double *)malloc( (s * p * sizeof(double)) + /* pixelCurrent array + */ ((p+((p+63)/64)) * bytesPerPixel)))) /* pixelOutBuffer */ { pixelOutBuffer = (unsigned char *)&pixelCurrent[s * p]; /* Alloc successful. Next phase... */ status = TC_ERR_OPEN; /* Currently rigged for a single FTDI device, and always index 0. Might address this in a future update if it's an issue. */ if(FT_OK == FT_Open(0,&ftdiHandle)) { status = TC_ERR_MODE; /* Currently hogs all pins as outputs, whether they're used by strands or not. */ if(FT_OK == FT_SetBitMode(ftdiHandle,255,1)) { status = TC_OK; /* Tentative success */ /* Try to set baud rate & divisor to non- default values. 3090000 seems to be the absolute max baud rate; even +1 more, and it fails. Failure of either of these steps returns a warning but does not abort; program can continue with default baud rate setting. FTDI docs suggest max of 3000000; this may be pushing it. */ if(FT_OK != FT_SetDivisor(ftdiHandle,1)) status = TC_ERR_DIVISOR; if(FT_OK != FT_SetBaudRate(ftdiHandle,3090000)) status = TC_ERR_BAUDRATE; /* Clear any lingering data in queue. */ (void)FT_Purge(ftdiHandle, FT_PURGE_RX | FT_PURGE_TX); return status; /* Success */ } /* Else fatal error of some sort. Clean up any interim results. */ FT_Close(ftdiHandle); } ftdiHandle = NULL; free(pixelCurrent); pixelCurrent = NULL; pixelOutBuffer = NULL; } return status; /* Fail */ }
int main() { char cBufWrite[BUF_SIZE]; char * pcBufRead = NULL; char * pcBufLD[MAX_DEVICES + 1]; char cBufLD[MAX_DEVICES][64]; DWORD dwRxSize = 0; DWORD dwBytesWritten, dwBytesRead; FT_STATUS ftStatus; FT_HANDLE ftHandle[MAX_DEVICES]; int iNumDevs = 0; int i, j; int iDevicesOpen; FT_DEVICE_LIST_INFO_NODE *devInfo; // // create the device information list // ftStatus = FT_CreateDeviceInfoList(&iNumDevs); if (ftStatus == FT_OK) { printf("Number of devices is %d\n",iNumDevs); } // // allocate storage for list based on numDevs // devInfo = (FT_DEVICE_LIST_INFO_NODE*)malloc(sizeof(FT_DEVICE_LIST_INFO_NODE)*iNumDevs); // // get the device information list // ftStatus = FT_GetDeviceInfoList(devInfo,&iNumDevs); if (ftStatus == FT_OK) { for (i = 0; i < iNumDevs; i++) { printf("Dev %d:\n",i); printf(" Flags=0x%x\n",devInfo[i].Flags); printf(" Type=0x%x\n",devInfo[i].Type); printf(" ID=0x%x\n",devInfo[i].ID); printf(" LocId=0x%x\n",devInfo[i].LocId); printf(" SerialNumber=%s\n",devInfo[i].SerialNumber); printf(" Description=%s\n",devInfo[i].Description); printf(" ftHandle=0x%x\n",devInfo[i].ftHandle); } } for(i = 0; i < MAX_DEVICES; i++) { pcBufLD[i] = cBufLD[i]; } pcBufLD[MAX_DEVICES] = NULL; ftStatus = FT_ListDevices(pcBufLD, &iNumDevs, FT_LIST_ALL | FT_OPEN_BY_SERIAL_NUMBER); // ftStatus = FT_ListDevices(pcBufLD, &iNumDevs, FT_LIST_ALL | FT_OPEN_BY_DESCRIPTION); if(ftStatus != FT_OK) { printf("Error: FT_ListDevices(%d)\n", ftStatus); return 1; } for(j = 0; j < BUF_SIZE; j++) { cBufWrite[j] = j; } for(i = 0; ( (i <MAX_DEVICES) && (i < iNumDevs) ); i++) { printf("Device %d Serial Number - %s\n", i, cBufLD[i]); } for(i = 0; ( (i <MAX_DEVICES) && (i < iNumDevs) ) ; i++) { /* Setup */ if((ftStatus = FT_OpenEx(cBufLD[i], FT_OPEN_BY_SERIAL_NUMBER, &ftHandle[i])) != FT_OK){ // if((ftStatus = FT_OpenEx(cBufLD[i], FT_OPEN_BY_DESCRIPTION, &ftHandle[i])) != 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("Error FT_OpenEx(%d), device\n", ftStatus, i); return 1; } // FT_SetDeadmanTimeout(ftHandle[i], 10000); iDevicesOpen++; if((ftStatus = FT_SetBaudRate(ftHandle[i], 9600)) != FT_OK) { printf("Error FT_SetBaudRate(%d), cBufLD[i] = %s\n", ftStatus, cBufLD[i]); break; } for(j = 0; j < BUF_SIZE; j++) { printf("cBufWrite[%d] = 0x%02X\n", j, cBufWrite[j]); } /* Write */ if((ftStatus = FT_Write(ftHandle[i], cBufWrite, BUF_SIZE, &dwBytesWritten)) != FT_OK) { printf("Error FT_Write(%d)\n", ftStatus); break; } sleep(1); /* Read */ dwRxSize = 0; while ((dwRxSize < BUF_SIZE) && (ftStatus == FT_OK)) { ftStatus = FT_GetQueueStatus(ftHandle[i], &dwRxSize); } if(ftStatus == FT_OK) { pcBufRead = (char*)realloc(pcBufRead, dwRxSize); memset(pcBufRead, 0xFF, dwRxSize); for(j = 0; j < dwRxSize; j++) { printf("b4 pcBufRead[%d] = 0x%02X\n", j, pcBufRead[j]); } if((ftStatus = FT_Read(ftHandle[i], pcBufRead, dwRxSize, &dwBytesRead)) != FT_OK) { printf("Error FT_Read(%d)\n", ftStatus); } else { printf("FT_Read = %d\n", dwBytesRead); for(j = 0; j < dwBytesRead; j++) { printf("aftr pcBufRead[%d] = 0x%02X\n", j, pcBufRead[j]); } } } else { printf("Error FT_GetQueueStatus(%d)\n", ftStatus); } } iDevicesOpen = i; /* Cleanup */ for(i = 0; i < iDevicesOpen; i++) { FT_Close(ftHandle[i]); printf("Closed device %s\n", cBufLD[i]); } if(pcBufRead) free(pcBufRead); return 0; }
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(); }
static void FTClassicPort_setBaudRate(FTClassicPort *self,ULONG BaudRate){ self->status = FT_SetBaudRate(self->handle, BaudRate); }
int openSerialPorts(int baud) { char * pcBufRead = NULL; char * pcBufLD[MAX_DEVICES + 1]; DWORD dwRxSize = 0; DWORD dwBytesWritten, dwBytesRead; FT_STATUS ftStatus; int iNumDevs = 0; int i, j; int iDevicesOpen; unsigned char ucMode = 0x00; printf( "warning: opening up to %d ports and assuming all are Safecast devices.\n", MAX_DEVICES ); printf( "todo: make this more selective and safer.\n" ); for(i = 0; i < MAX_DEVICES; i++) { pcBufLD[i] = cBufLD[i]; } pcBufLD[MAX_DEVICES] = NULL; ftStatus = FT_ListDevices(pcBufLD, &iNumDevs, FT_LIST_ALL | FT_OPEN_BY_SERIAL_NUMBER); if(ftStatus != FT_OK) { printf("Error: FT_ListDevices(%d)\n", ftStatus); return -1; } for(i = 0; ( (i <MAX_DEVICES) && (i < iNumDevs) ); i++) { printf("Device %d Serial Number - %s\n", i, cBufLD[i]); } for(i = 0; ( (i <MAX_DEVICES) && (i < iNumDevs) ) ; i++) { /* Setup */ if((ftStatus = FT_OpenEx(cBufLD[i], FT_OPEN_BY_SERIAL_NUMBER, &ftHandle[i])) != 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("Error FT_OpenEx(%d), device\n", ftStatus); return -1; } printf("Opened device %s\n", cBufLD[i]); // if(getandcheckCBUS(ftHandle[i]) ) { // printf( "getandcheckCBUS failed, exiting.\n" ); // return -1; // } iDevicesOpen++; if((ftStatus = FT_SetBaudRate(ftHandle[i], baud)) != FT_OK) { printf("Error FT_SetBaudRate(%d), cBufLD[i] = %s\n", ftStatus, cBufLD[i]); break; } if((ftStatus = FT_SetDataCharacteristics(ftHandle[i], FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_EVEN)) != FT_OK) { printf("Error FT_SetDataCharacteristics(%d) = %s\n", ftStatus, cBufLD[i]); break; } FT_SetTimeouts(ftHandle[i], 500, 500); // 500 ms read/write timeout } iDevicesOpen = i; foundDevices = i; // record this in a global if(pcBufRead) free(pcBufRead); return 0; // we always use the 0th device for now }
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); }