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 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 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 }
int nifalcon_open(falcon_device *dev, unsigned int device_index) { unsigned int falcon_count = 0, device_count = 0, i = 0; char* pcBufLD[MAX_DEVICES + 1]; char cBufLD[MAX_DEVICES][64]; char serial[64]; //If we're not using windows, we can set PID/VID to filter on. I have no idea why this isn't provided in the windows drivers. #ifndef WIN32 FT_SetVIDPID(0x0403, 0xCB48); #endif for(i = 0; i < MAX_DEVICES; i++) { pcBufLD[i] = cBufLD[i]; } if((dev->falcon_status_code = FT_ListDevices(pcBufLD, &device_count, FT_LIST_ALL | FT_OPEN_BY_DESCRIPTION)) != FT_OK) return -dev->falcon_status_code; for(i = 0; (i < device_count) && (falcon_count <= device_index); ++i) { if(!strcmp(cBufLD[i], NIFALCON_DESCRIPTION)) falcon_count++; } if(falcon_count == 0) nifalcon_error_return(NIFALCON_DEVICE_NOT_FOUND_ERROR, "no devices connected to system"); if(device_index > falcon_count) nifalcon_error_return(NIFALCON_DEVICE_INDEX_OUT_OF_RANGE_ERROR, "device index out of range"); //Now that we know the index, get the serial number if((dev->falcon_status_code = FT_ListDevices((PVOID)(i-1), serial, FT_LIST_BY_INDEX | FT_OPEN_BY_SERIAL_NUMBER))) return -dev->falcon_status_code; //Open and reset device using serial number if((dev->falcon_status_code = FT_OpenEx(serial, FT_OPEN_BY_SERIAL_NUMBER, &(dev->falcon))) != FT_OK) return -dev->falcon_status_code; dev->is_open = 1; return FT_OK; }
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; }
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; }
CKMotionIO::CKMotionIO() { ConsoleHandler=NULL; Mutex = new CMutex(FALSE,"KMotionIO",NULL); m_Connected=false; SendAbortOnConnect=true; FailMessageAlreadyShown=false; Token=0; NonRespondingCount=0; m_FirmwareVersion=2; USB_Loc_ID=-1; BoardIDAssigned=false; #ifdef _KMOTIONX //FT_SetVIDPID(VENDOR, PRODUCT); FT_SetVIDPID(1027, 62001); #endif }
int nifalcon_get_count(falcon_device* dev) { unsigned int falcon_count = 0, device_count = 0, i = 0; char* pcBufLD[MAX_DEVICES + 1]; char cBufLD[MAX_DEVICES][64]; for(i = 0; i < MAX_DEVICES; i++) { pcBufLD[i] = cBufLD[i]; } //If we're not using windows, we can set PID/VID to filter on. I have no idea why this isn't provided in the windows drivers. #ifndef WIN32 FT_SetVIDPID(0x0403, 0xCB48); #endif if((dev->falcon_status_code = FT_ListDevices(pcBufLD, &device_count, FT_LIST_ALL | FT_OPEN_BY_DESCRIPTION)) != FT_OK) return -dev->falcon_status_code; for(i = 0; i < device_count; ++i) { if(!strcmp(cBufLD[i], NIFALCON_DESCRIPTION)) ++falcon_count; } return falcon_count; }
FT_STATUS Find(int vid, int pid) { FT_STATUS status; FT_SetVIDPID(vid, pid); DWORD numDevs = 0; status = FT_CreateDeviceInfoList(&numDevs); if (numDevs > 0) { // allocate storage for list based on numDevs FT_DEVICE_LIST_INFO_NODE *devInfo = new FT_DEVICE_LIST_INFO_NODE[numDevs]; memset(devInfo, 0, numDevs*sizeof(FT_DEVICE_LIST_INFO_NODE)); // get the device information list status = FT_GetDeviceInfoList(devInfo, &numDevs); printf("\nFound Devices: %d\r\n", numDevs); for(int i = 0; i < numDevs; i++) { // FT_HANDLE handy; // FT_GetDeviceInfoDetail (i, // &devInfo[i].Flags, // &devInfo[i].Type, // &devInfo[i].ID, // &devInfo[i].LocId, // devInfo[i].SerialNumber, // &devInfo[i].Description, // &handy); printf("%s\r\n", devInfo[i].Description); printf("%s\r\n", devInfo[i].SerialNumber); printf("Open: %d\n", devInfo[i].Flags & 0x1); } delete[] devInfo; } return status; }
int main(int argc, char *argv[]) { FT_STATUS ftStatus; FT_HANDLE ftHandle0; int iport; FT_PROGRAM_DATA Data; if(argc > 1) { sscanf(argv[1], "%d", &iport); } else { iport = 0; } printf("opening port %d\n", iport); FT_SetVIDPID(0x0403, 0x6011); ftStatus = FT_Open(iport, &ftHandle0); 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; } printf("ftHandle0 = %p\n", ftHandle0); #ifndef BM_DEVICE Data.Signature1 = 0x00000000; Data.Signature2 = 0xffffffff; Data.VendorId = 0x0403; Data.ProductId = 0x6001; Data.Manufacturer = "FTDI"; Data.ManufacturerId = "FT"; Data.Description = "USB <-> Serial"; Data.SerialNumber = "FT000001"; // if fixed, or NULL Data.MaxPower = 44; Data.PnP = 1; Data.SelfPowered = 0; Data.RemoteWakeup = 1; Data.Rev4 = 1; Data.IsoIn = 0; Data.IsoOut = 0; Data.PullDownEnable = 1; Data.SerNumEnable = 1; Data.USBVersionEnable = 0; Data.USBVersion = 0x110; #else // If 2232C Data.Signature1 = 0x00000000; Data.Signature2 = 0xffffffff; Data.VendorId = 0x0403; Data.ProductId = 0x6010; Data.Manufacturer = "FTDI"; Data.ManufacturerId = "FT"; Data.Description = "SPI"; Data.SerialNumber = "FT123452"; // if fixed, or NULL Data.MaxPower = 200; Data.PnP = 1; Data.SelfPowered = 0; Data.RemoteWakeup = 0; Data.Rev4 = 0; Data.IsoIn = 0; Data.IsoOut = 0; Data.PullDownEnable = 0; Data.SerNumEnable = 0; Data.USBVersionEnable = 0; Data.USBVersion = 0; Data.Rev5 = 1; // non-zero if Rev5 chip, zero otherwise Data.IsoInA = 0; // non-zero if in endpoint is isochronous Data.IsoInB = 0; // non-zero if in endpoint is isochronous Data.IsoOutA = 0; // non-zero if out endpoint is isochronous Data.IsoOutB = 0; // non-zero if out endpoint is isochronous Data.PullDownEnable5 = 0; // non-zero if pull down enabled Data.SerNumEnable5 = 1; // non-zero if serial number to be used Data.USBVersionEnable5 = 0; // non-zero if chip uses USBVersion Data.USBVersion5 = 0x0200; // BCD (0x0200 => USB2) Data.AIsHighCurrent = 0; // non-zero if interface is high current Data.BIsHighCurrent = 0; // non-zero if interface is high current Data.IFAIsFifo = 1; // non-zero if interface is 245 FIFO Data.IFAIsFifoTar = 0; // non-zero if interface is 245 FIFO CPU target Data.IFAIsFastSer = 0; // non-zero if interface is Fast serial Data.AIsVCP = 0; // non-zero if interface is to use VCP drivers Data.IFBIsFifo = 1; // non-zero if interface is 245 FIFO Data.IFBIsFifoTar = 0; // non-zero if interface is 245 FIFO CPU target Data.IFBIsFastSer = 0; // non-zero if interface is Fast serial Data.BIsVCP = 0; // non-zero if interface is to use VCP drivers #endif ftStatus = FT_EE_Program(ftHandle0, &Data); if(ftStatus != FT_OK) { printf("FT_EE_Program failed (%d)\n", ftStatus); FT_Close(ftHandle0); } FT_Close(ftHandle0); return 0; }
int main(int argc, char *argv[]) { FT_STATUS ftStatus; FT_HANDLE ftHandle0; int iport; FT_PROGRAM_DATA Data; char *serialstr; if(argc == 3) { sscanf(argv[1], "%d", &iport); serialstr = argv[2]; } else { fprintf(stderr, "syntax: %s iPort serialPrefix serialNumber\n", argv[0]); return -1; } //printf("opening port %d\n", iport); FT_SetVIDPID(0x0403, 0x6014); ftStatus = FT_Open(iport, &ftHandle0); 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 port %d failed\n", iport); return 1; } Data.Signature1 = 0x00000000; Data.Signature2 = 0xffffffff; Data.Version = 5; //FT232H Data.VendorId = 0x0403; Data.ProductId = 0x6014; Data.Manufacturer = "DLRC"; Data.ManufacturerId = "FT"; Data.Description = "DLRC SNAPNODE Plus Rev 2.0"; Data.SerialNumber = serialstr; // if fixed, or NULL Data.MaxPower = 500; Data.PnP = 1; Data.SelfPowered = 0; Data.RemoteWakeup = 1; //FT232H Data.PullDownEnableH = 1; // non-zero if pull down enabled Data.SerNumEnableH = 1; // non-zero if serial number to be used Data.ACSlowSlewH = 0; // non-zero if AC pins have slow slew Data.ACSchmittInputH = 0; // non-zero if AC pins are Schmitt input Data.ACDriveCurrentH = 4; // valid values are 4mA, 8mA, 12mA, 16mA Data.ADSlowSlewH = 0; // non-zero if AD pins have slow slew Data.ADSchmittInputH = 0; // non-zero if AD pins are Schmitt input Data.ADDriveCurrentH = 4; // valid values are 4mA, 8mA, 12mA, 16mA Data.Cbus0H = 0; // Cbus Mux control Data.Cbus1H = 0; // Cbus Mux control Data.Cbus2H = 0; // Cbus Mux control Data.Cbus3H = 1; // Cbus Mux control Data.Cbus4H = 2; // Cbus Mux control Data.Cbus5H = 0; // Cbus Mux control Data.Cbus6H = 0; // Cbus Mux control Data.Cbus7H = 0; // Cbus Mux control Data.Cbus8H = 0; // Cbus Mux control Data.Cbus9H = 0; // Cbus Mux control Data.IsFifoH = 0; // non-zero if interface is 245 FIFO Data.IsFifoTarH = 0; // non-zero if interface is 245 FIFO CPU target Data.IsFastSerH = 0; // non-zero if interface is Fast serial Data.IsFT1248H = 0; // non-zero if interface is FT1248 Data.FT1248CpolH = 0; // FT1248 clock polarity - clock idle high (1) or clock idle low (0) Data.FT1248LsbH = 0; // FT1248 data is LSB (1) or MSB (0) Data.FT1248FlowControlH = 0;// FT1248 flow control enable Data.IsVCPH = 1; // non-zero if interface is to use VCP drivers Data.PowerSaveEnableH = 1; // non-zero if using ACBUS7 to save power for self-powered designs #ifdef H2232_DEVICE // If 2232C Data.Signature1 = 0x00000000; Data.Signature2 = 0xffffffff; Data.VendorId = 0x0403; Data.ProductId = 0x6010; Data.Manufacturer = "FTDI"; Data.ManufacturerId = "FT"; Data.Description = "SPI"; Data.SerialNumber = "FT123452"; // if fixed, or NULL Data.MaxPower = 200; Data.PnP = 1; Data.SelfPowered = 0; Data.RemoteWakeup = 0; Data.Rev4 = 0; Data.IsoIn = 0; Data.IsoOut = 0; Data.PullDownEnable = 0; Data.SerNumEnable = 0; Data.USBVersionEnable = 0; Data.USBVersion = 0; Data.Rev5 = 1; // non-zero if Rev5 chip, zero otherwise Data.IsoInA = 0; // non-zero if in endpoint is isochronous Data.IsoInB = 0; // non-zero if in endpoint is isochronous Data.IsoOutA = 0; // non-zero if out endpoint is isochronous Data.IsoOutB = 0; // non-zero if out endpoint is isochronous Data.PullDownEnable5 = 0; // non-zero if pull down enabled Data.SerNumEnable5 = 1; // non-zero if serial number to be used Data.USBVersionEnable5 = 0; // non-zero if chip uses USBVersion Data.USBVersion5 = 0x0200; // BCD (0x0200 => USB2) Data.AIsHighCurrent = 0; // non-zero if interface is high current Data.BIsHighCurrent = 0; // non-zero if interface is high current Data.IFAIsFifo = 1; // non-zero if interface is 245 FIFO Data.IFAIsFifoTar = 0; // non-zero if interface is 245 FIFO CPU target Data.IFAIsFastSer = 0; // non-zero if interface is Fast serial Data.AIsVCP = 0; // non-zero if interface is to use VCP drivers Data.IFBIsFifo = 1; // non-zero if interface is 245 FIFO Data.IFBIsFifoTar = 0; // non-zero if interface is 245 FIFO CPU target Data.IFBIsFastSer = 0; // non-zero if interface is Fast serial Data.BIsVCP = 0; // non-zero if interface is to use VCP drivers #endif ftStatus = FT_EE_Program(ftHandle0, &Data); if(ftStatus != FT_OK) { printf("FT_EE_Program failed (%d)\n", (int)ftStatus); FT_Close(ftHandle0); return -1; } //FT_CyclePort(ftHandle0); FT_Close(ftHandle0); return 0; }
CMmcUsbHndlBase::CMmcUsbHndlBase() { FT_SetVIDPID(0x403,0xa8b0); }
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); }
static int presto_open_ftd2xx(char *req_serial) { uint32_t i; DWORD numdevs; DWORD vidpid; char devname[FT_DEVICE_NAME_LEN]; FT_DEVICE device; BYTE presto_data; DWORD ftbytes; presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE; #if IS_WIN32 == 0 /* Add non-standard Vid/Pid to the linux driver */ presto->status = FT_SetVIDPID(PRESTO_VID, PRESTO_PID); if (presto->status != FT_OK) { LOG_ERROR("couldn't add PRESTO VID/PID"); exit(-1); } #endif presto->status = FT_ListDevices(&numdevs, NULL, FT_LIST_NUMBER_ONLY); if (presto->status != FT_OK) { LOG_ERROR("FT_ListDevices failed: %s", ftd2xx_status_string(presto->status)); return ERROR_JTAG_DEVICE_ERROR; } LOG_DEBUG("FTDI devices available: %" PRIu32, (uint32_t)numdevs); for (i = 0; i < numdevs; i++) { presto->status = FT_Open(i, &(presto->handle)); if (presto->status != FT_OK) { /* this is not fatal, the device may be legitimately open by other process, *hence debug message only */ LOG_DEBUG("FT_Open failed: %s", ftd2xx_status_string(presto->status)); continue; } LOG_DEBUG("FTDI device %i open", (int)i); presto->status = FT_GetDeviceInfo(presto->handle, &device, &vidpid, presto->serial, devname, NULL); if (presto->status == FT_OK) { if (vidpid == PRESTO_VID_PID && (req_serial == NULL || !strcmp(presto->serial, req_serial))) break; } else LOG_DEBUG("FT_GetDeviceInfo failed: %s", ftd2xx_status_string( presto->status)); LOG_DEBUG("FTDI device %i does not match, closing", (int)i); FT_Close(presto->handle); presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE; } if (presto->handle == (FT_HANDLE)INVALID_HANDLE_VALUE) return ERROR_JTAG_DEVICE_ERROR; /* presto not open, return */ presto->status = FT_SetLatencyTimer(presto->handle, 1); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; presto->status = FT_SetTimeouts(presto->handle, 100, 0); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; presto_data = 0xD0; presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; /* delay between first write/read turnaround (after purge?) necessary * under Linux for unknown reason, * probably a bug in library threading */ usleep(100000); presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; if (ftbytes != 1) { LOG_DEBUG("PRESTO reset"); presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; presto->status = FT_SetBitMode(presto->handle, 0x80, 1); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; presto->status = FT_SetBaudRate(presto->handle, 9600); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; presto_data = 0; for (i = 0; i < 4 * 62; i++) { presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; } usleep(100000); presto->status = FT_SetBitMode(presto->handle, 0x00, 0); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; presto_data = 0xD0; presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; /* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason, probably a bug in library threading */ usleep(100000); presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; if (ftbytes != 1) { LOG_DEBUG("PRESTO not responding"); return ERROR_JTAG_DEVICE_ERROR; } } presto->status = FT_SetTimeouts(presto->handle, 0, 0); if (presto->status != FT_OK) return ERROR_JTAG_DEVICE_ERROR; presto->status = FT_Write(presto->handle, &presto_init_seq, sizeof(presto_init_seq), &ftbytes); if (presto->status != FT_OK || ftbytes != sizeof(presto_init_seq)) return ERROR_JTAG_DEVICE_ERROR; return ERROR_OK; }
int main(int argc, char *argv[]) { FT_STATUS ftStatus; FT_HANDLE ftHandle0; int iport; FT_PROGRAM_DATA Data; FT_DEVICE ftDevice; if(argc > 1) { sscanf(argv[1], "%d", &iport); } else { iport = 0; } printf("opening port %d\n", iport); FT_SetVIDPID(0x0403, 0x6017); ftStatus = FT_Open(iport, &ftHandle0); 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; } printf("ftHandle0 = %p\n", ftHandle0); ftStatus = FT_GetDeviceInfo( ftHandle0, &ftDevice, NULL, NULL, NULL, NULL ); if (ftStatus != FT_OK) { printf("FT_GetDeviceType FAILED!\n"); return 1; } if (ftDevice == FT_DEVICE_BM) { Data.Signature1 = 0x00000000; Data.Signature2 = 0xffffffff; Data.VendorId = 0x0403; Data.ProductId = 0x6001; Data.Manufacturer = "FTDI"; Data.ManufacturerId = "FT"; Data.Description = "USB <-> Srial"; Data.SerialNumber = "FT000001"; // if fixed, or NULL Data.MaxPower = 44; Data.PnP = 1; Data.SelfPowered = 0; Data.RemoteWakeup = 1; Data.Rev4 = 1; Data.IsoIn = 0; Data.IsoOut = 0; Data.PullDownEnable = 1; Data.SerNumEnable = 1; Data.USBVersionEnable = 0; Data.USBVersion = 0x110; } else if (ftDevice == FT_DEVICE_232R) { Data.Signature1 = 0x00000000; Data.Signature2 = 0xffffffff; Data.Version = 2; Data.VendorId = 0x0403; Data.ProductId = 0x6001 ; Data.Manufacturer = "FTDI"; Data.ManufacturerId = "FT"; Data.Description = "USB <-> Serial"; Data.SerialNumber = "FT000008"; // if fixed, or NULL Data.MaxPower = 100; Data.PnP = 1; Data.SelfPowered = 0; Data.RemoteWakeup = 1; Data.UseExtOsc = 0x00; // Use External Oscillator Data.HighDriveIOs = 0x00; // High Drive I/Os Data.EndpointSize = 0x40; // Endpoint size Data.PullDownEnableR = 0x00; // non-zero if pull down enabled Data.SerNumEnableR = 0x01; // non-zero if serial number to be used Data.InvertTXD = 0x00; // non-zero if invert TXD Data.InvertRXD = 0x00; // non-zero if invert RXD Data.InvertRTS = 0x00; // non-zero if invert RTS Data.InvertCTS = 0x00; // non-zero if invert CTS Data.InvertDTR = 0x00; // non-zero if invert DTR Data.InvertDSR = 0x00; // non-zero if invert DSR Data.InvertDCD = 0x00; // non-zero if invert DCD Data.InvertRI = 0x00; // non-zero if invert RI Data.Cbus0 = 0x02; // Cbus Mux control Data.Cbus1 = 0x03; // Cbus Mux control Data.Cbus2 = 0x01; // Cbus Mux control Data.Cbus3 = 0x01; // Cbus Mux control Data.Cbus4 = 0x05; // Cbus Mux control Data.RIsD2XX = 0; // non-zero if using VCP drivers } else if (ftDevice == FT_DEVICE_2232C) { Data.Signature1 = 0x00000000; Data.Signature2 = 0xffffffff; Data.VendorId = 0x0403; Data.ProductId = 0x6010; Data.Manufacturer = "FTDI"; Data.ManufacturerId = "FT"; Data.Description = "USB <-> Serial"; Data.SerialNumber = "FT123442"; // if fixed, or NULL Data.MaxPower = 200; Data.PnP = 1; Data.SelfPowered = 0; Data.RemoteWakeup = 0; Data.Rev5 = 1; // non-zero if Rev5 chip, zero otherwise Data.IsoInA = 0; // non-zero if in endpoint is isochronous Data.IsoInB = 0; // non-zero if in endpoint is isochronous Data.IsoOutA = 0; // non-zero if out endpoint is isochronous Data.IsoOutB = 0; // non-zero if out endpoint is isochronous Data.PullDownEnable5 = 0; // non-zero if pull down enabled Data.SerNumEnable5 = 1; // non-zero if serial number to be used Data.USBVersionEnable5 = 0; // non-zero if chip uses USBVersion Data.USBVersion5 = 0x0200; // BCD (0x0200 => USB2) Data.AIsHighCurrent = 0; // non-zero if interface is high current Data.BIsHighCurrent = 0; // non-zero if interface is high current Data.IFAIsFifo = 0; // non-zero if interface is 245 FIFO Data.IFAIsFifoTar = 0; // non-zero if interface is 245 FIFO CPU target Data.IFAIsFastSer = 0; // non-zero if interface is Fast serial Data.AIsVCP = 0; // non-zero if interface is to use VCP drivers Data.IFBIsFifo = 0; // non-zero if interface is 245 FIFO Data.IFBIsFifoTar = 0; // non-zero if interface is 245 FIFO CPU target Data.IFBIsFastSer = 0; // non-zero if interface is Fast serial Data.BIsVCP = 0; // non-zero if interface is to use VCP drivers } ftStatus = FT_EE_Program(ftHandle0, &Data); if(ftStatus != FT_OK) { printf("FT_EE_Program failed (%d)\n", ftStatus); } FT_Close(ftHandle0); return 0; }
int main(int argc, char *argv[]) { static const struct option long_opts[] = { {"prompt", no_argument, NULL, 'p'}, {"verbose", no_argument, NULL, 'v'}, {"help", no_argument, NULL, 'h'}, {NULL, no_argument, NULL, 0} }; opterr = 0; int c; int option_index = 0; while ((c = getopt_long(argc, argv, "vph", long_opts, &option_index)) != -1) switch (c) { case 'v': verbose++; break; case 'p': dont_prompt++; break; case 'h': print_usage(); return EXIT_SUCCESS; case '?': fprintf(stderr, "Unknown option `-%c'.\n", optopt); return EXIT_FAILURE; default: abort(); } DWORD num_devs; DWORD VID, PID; int iport = 0; /* See how many devices are plugged in, fail if greater than 1 */ if (verbose) printf("Creating device info list\n"); ft_status = FT_CreateDeviceInfoList(&num_devs); if (ft_status != FT_OK){ fprintf(stderr,"ERROR : Failed to create device info list, ft_status = %d\n",ft_status); return EXIT_FAILURE; } if (verbose) printf("Making sure only one FTDI device is plugged in\n"); /* Check that there aren't more than 1 device plugged in */ if (num_devs > 1){ fprintf(stderr,"ERROR : More than one FTDI device plugged in\n"); return EXIT_FAILURE; } /* Get VID/PID from FTDI device */ if (verbose) printf("Getting VID/PID from device\n"); ft_status = FT_GetVIDPID(&VID,&PID); if (ft_status != FT_OK){ fprintf(stderr,"ERROR : Failed to get VID and PID from FTDI device, ft_status = %d\n",ft_status); return EXIT_FAILURE; } if (verbose) printf(" VID = %04x, PID = %04x\n",VID,PID); /* Set the VID/PID found */ if (verbose) printf("Setting VID/PID\n"); ft_status = FT_SetVIDPID(VID,PID); if (ft_status != FT_OK){ fprintf(stderr,"ERROR : Failed to set VID and PID, ft_status = %d\n",ft_status); return EXIT_FAILURE; } /* Get info about the device and print to user */ //FT_GetDeviceInfoDetail seems to not work very reliably //DWORD lpdw_flags; //DWORD lpdw_type; //DWORD lpdw_id; //char pc_serial_number[16]; //char pc_description[64]; //ft_status = FT_GetDeviceInfoDetail(0,&lpdw_flags,&lpdw_type,&lpdw_id,NULL,pc_serial_number,pc_description,&ft_handle); //if (ft_status != FT_OK){ // fprintf(stderr,"ERROR : Failed to get device info, ft_status = %d\n",ft_status); // return EXIT_FAILURE; //} //if (verbose || !dont_prompt){ // printf("Device Information : \n"); // printf(" Description : %s\n", pc_description); // printf(" Serial Number : %s\n", pc_serial_number); // printf(" Flags : 0x%x\n", lpdw_flags); // printf(" Type : 0x%x\n", lpdw_type); // printf(" ID : 0x%x\n", lpdw_id); //} /* Ask user if this is the correct device */ if (!dont_prompt) { char correct_device; printf("Is this the correct device? (y/n) : "); scanf("%c",&correct_device); while ((correct_device != 'y') && (correct_device != 'n')) { printf("\rPlease enter y or n"); scanf("%c",&correct_device); } if (correct_device == 'n'){ printf("Exiting, since this is not the device we want to program\n"); return EXIT_SUCCESS; } } /* Open the device */ if (verbose) printf("Attempting to open device using read VID/PID..."); ft_status = FT_Open(iport, &ft_handle); /* If that didn't work, try some other likely VID/PID combos */ /* Try 0403:6014 */ if (ft_status != FT_OK){ if (verbose) printf("FAILED\nTrying VID=0x0403, PID=0x6014..."); ft_status = FT_SetVIDPID(0x0403,0x6014); if (ft_status != FT_OK){ fprintf(stderr,"ERROR : Failed to set VID and PID, ft_status = %d\n",ft_status); return EXIT_FAILURE; } ft_status = FT_Open(iport, &ft_handle); } /* Try 0403:8398 */ if (ft_status != FT_OK){ if (verbose) printf("FAILED\nTrying VID=0x0403, PID=0x8398..."); ft_status = FT_SetVIDPID(0x0403,0x8398); if (ft_status != FT_OK){ fprintf(stderr,"ERROR : Failed to set VID and PID, ft_status = %d\n",ft_status); return EXIT_FAILURE; } ft_status = FT_Open(iport, &ft_handle); } /* Exit program if we still haven't opened the device */ if (ft_status != FT_OK){ if (verbose) printf("FAILED\n"); fprintf(stderr,"ERROR : Failed to open device : ft_status = %d\nHave you tried (sudo rmmod ftdi_sio)?\n",ft_status); return EXIT_FAILURE; } if (verbose) printf("SUCCESS\n"); /* Erase the EEPROM */ ft_status = FT_EraseEE(ft_handle); if(ft_status != FT_OK) { fprintf(stderr, "ERROR: Device EEPROM could not be erased : ft_status = %d\n", ft_status); return EXIT_FAILURE; } if (verbose) printf("Erased device's EEPROM\n"); /* Assign appropriate values to eeprom data */ eeprom_data.Signature1 = 0x00000000; eeprom_data.Signature2 = 0xffffffff; eeprom_data.Version = 5; /* 5=FT232H */ eeprom_data.VendorId = USB_CUSTOM_VID; eeprom_data.ProductId = USB_CUSTOM_PID; eeprom_data.Manufacturer = "FTDI"; eeprom_data.ManufacturerId = "FT"; eeprom_data.Description = "Piksi Passthrough"; eeprom_data.IsFifoH = 1; /* needed for FIFO samples passthrough */ /* Program device EEPROM */ ft_status = FT_EE_Program(ft_handle, &eeprom_data); if (ft_status != FT_OK) { fprintf(stderr,"ERROR : Failed to program device EEPROM : ft_status = %d\n",ft_status); return EXIT_FAILURE; } if (verbose) printf("Programmed device's EEPROM\n"); /* Reset the device */ ft_status = FT_ResetDevice(ft_handle); if (ft_status != FT_OK) { fprintf(stderr, "ERROR: Device could not be reset : ft_status = %d\n", ft_status); return EXIT_FAILURE; } if (verbose) printf("Reset device\n"); /* Close the device */ if (verbose) printf("Closing device\n"); FT_Close(ft_handle); if(ft_status != FT_OK) { fprintf(stderr,"ERROR : Failed to close device : ft_status = %d\n",ft_status); return EXIT_FAILURE; } printf("Re-configuring for FIFO mode successful, please unplug and replug your device now\n"); return EXIT_SUCCESS; }
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; }
static int ublast_ftd2xx_init(struct ublast_lowlevel *low) { FT_STATUS status; FT_HANDLE *ftdih = ublast_getftdih(low); uint8_t latency_timer; LOG_INFO("usb blaster interface using FTD2XX"); /* Open by device description */ if (low->ublast_device_desc == NULL) { LOG_WARNING("no usb blaster device description specified, " "using default 'USB-Blaster'"); low->ublast_device_desc = "USB-Blaster"; } #if IS_WIN32 == 0 /* Add non-standard Vid/Pid to the linux driver */ status = FT_SetVIDPID(low->ublast_vid, low->ublast_pid); if (status != FT_OK) { LOG_WARNING("couldn't add %4.4x:%4.4x", low->ublast_vid, low->ublast_pid); } #endif status = FT_OpenEx(low->ublast_device_desc, FT_OPEN_BY_DESCRIPTION, ftdih); if (status != FT_OK) { DWORD num_devices; LOG_ERROR("unable to open ftdi device: %s", ftd2xx_status_string(status)); status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY); if (status == FT_OK) { char **desc_array = malloc(sizeof(char *) * (num_devices + 1)); unsigned int i; for (i = 0; i < num_devices; i++) desc_array[i] = malloc(64); desc_array[num_devices] = NULL; status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | FT_OPEN_BY_DESCRIPTION); if (status == FT_OK) { LOG_ERROR("ListDevices: %" PRIu32, (uint32_t)num_devices); for (i = 0; i < num_devices; i++) LOG_ERROR("%i: %s", i, desc_array[i]); } for (i = 0; i < num_devices; i++) free(desc_array[i]); free(desc_array); } else { printf("ListDevices: NONE\n"); } return ERROR_JTAG_INIT_FAILED; } status = FT_SetLatencyTimer(*ftdih, 2); if (status != FT_OK) { LOG_ERROR("unable to set latency timer: %s", ftd2xx_status_string(status)); return ERROR_JTAG_INIT_FAILED; } status = FT_GetLatencyTimer(*ftdih, &latency_timer); if (status != FT_OK) { LOG_ERROR("unable to get latency timer: %s", ftd2xx_status_string(status)); return ERROR_JTAG_INIT_FAILED; } LOG_DEBUG("current latency timer: %i", latency_timer); status = FT_SetBitMode(*ftdih, 0x00, 0); if (status != FT_OK) { LOG_ERROR("unable to disable bit i/o mode: %s", ftd2xx_status_string(status)); return ERROR_JTAG_INIT_FAILED; } return ERROR_OK; }
int main(int argc, char *argv[]) { static const struct option long_opts[] = { {"verbose", no_argument, NULL, 'v'}, {"help", no_argument, NULL, 'h'}, {"id", required_argument, NULL, 'i'}, {NULL, no_argument, NULL, 0} }; opterr = 0; int c; int option_index = 0; while ((c = getopt_long(argc, argv, "vhi:", long_opts, &option_index)) != -1) switch (c) { case 'v': verbose++; break; case 'h': print_usage(); return EXIT_SUCCESS; case 'i': { pid = parse_pid(optarg); if (!pid) { fprintf(stderr, "Invalid ID argument.\n"); return EXIT_FAILURE; } break; } case '?': if (optopt == 'i') fprintf(stderr, "ID argument requires an argument.\n"); else fprintf(stderr, "Unknown option `-%c'.\n", optopt); return EXIT_FAILURE; default: abort(); } int iport = 0; /* Try to open device using input PID, or our custom PID if no input. */ if (verbose) printf("Trying to open with VID=0x%04x, PID=0x%04x...",USB_CUSTOM_VID,pid); ft_status = FT_SetVIDPID(USB_CUSTOM_VID, pid); if (ft_status != FT_OK){ fprintf(stderr,"ERROR : Failed to set VID and PID, ft_status = %d\n",ft_status); return EXIT_FAILURE; } ft_status = FT_Open(iport, &ft_handle); /* Exit program if we haven't opened the device. */ if (ft_status != FT_OK){ if (verbose) printf("FAILED\n"); fprintf(stderr,"ERROR : Failed to open device : ft_status = %d\n",ft_status); return EXIT_FAILURE; } if (verbose) printf("SUCCESS\n"); /* Erase the EEPROM to set the device to UART mode. */ if (verbose) printf("Erasing device EEPROM\n"); ft_status = FT_EraseEE(ft_handle); if(ft_status != FT_OK) { fprintf(stderr, "ERROR: Device EEPROM could not be erased : ft_status = %d\n", ft_status); return EXIT_FAILURE; } /* Reset the device. */ if (verbose) printf("Resetting device\n"); ft_status = FT_ResetDevice(ft_handle); if(ft_status != FT_OK) { fprintf(stderr, "ERROR: Device could not be reset : ft_status = %d\n", ft_status); return EXIT_FAILURE; } /* Close the device. */ if (verbose) printf("Closing device\n"); FT_Close(ft_handle); if(ft_status != FT_OK) { fprintf(stderr,"ERROR : Failed to close device : ft_status = %d\n",ft_status); return EXIT_FAILURE; } if (verbose) printf("Re-configuring for UART mode successful, please unplug and replug your device now\n"); return EXIT_SUCCESS; }
int main() { unsigned char cBufWrite[BUF_SIZE]; unsigned char * pcBufRead = NULL; char * pcBufLD[MAX_DEVICES + 1]; char cBufLD[MAX_DEVICES][64]; DWORD dwRxSize = 0, dwRxSizeTemp = 0; DWORD dwBytesWritten, dwBytesRead; FT_STATUS ftStatus; FT_HANDLE ftHandle[MAX_DEVICES]; int iNumDevs = 0; int i, j; int iDevicesOpen = 0; printf("Program start.\n"); for (i = 0; i < MAX_DEVICES; i++) { pcBufLD[i] = cBufLD[i]; } pcBufLD[MAX_DEVICES] = NULL; FT_SetVIDPID(1027, 59530); // use our VID and PID ftStatus = FT_ListDevices(pcBufLD, &iNumDevs, FT_LIST_ALL | FT_OPEN_BY_SERIAL_NUMBER); if (ftStatus != FT_OK) { printf("Error: FT_ListDevices(%d)\n", (int) ftStatus); return 1; } for (i = 0; ((i < MAX_DEVICES) && (i < iNumDevs)); i++) { printf("Device %d Serial Number - %s\n", i, cBufLD[i]); } for (j = 0; j < BUF_SIZE; j++) { cBufWrite[j] = j; } printf("Number of devices: %d.\n", iNumDevs); 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 %d\n", (int) ftStatus, i); 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"); return 1; } printf("Opened device %s\n", cBufLD[i]); iDevicesOpen++; if ((ftStatus = FT_SetBaudRate(ftHandle[i], 9600)) != FT_OK) { printf("Error FT_SetBaudRate(%d), cBufLD[i] = %s\n", (int) ftStatus, cBufLD[i]); break; } // printf("Calling FT_Write with this write-buffer:\n"); // dumpBuffer(cBufWrite, BUF_SIZE, 1); /* Write */ /* ftStatus = FT_Write(ftHandle[i], cBufWrite, BUF_SIZE, &dwBytesWritten); if (ftStatus != FT_OK) { printf("Error FT_Write(%d)\n", (int)ftStatus); break; } if (dwBytesWritten != (DWORD)BUF_SIZE) { printf("FT_Write only wrote %d (of %d) bytes\n", (int)dwBytesWritten, BUF_SIZE); break; } sleep(1); */ /* Read */ // load buffer dwRxSize = 0; dwRxSizeTemp = 0; printf("Fill Buffer (Size: %d)...\n", BUF_SIZE); while ((dwRxSize < BUF_SIZE) && (ftStatus == FT_OK)) { ftStatus = FT_GetQueueStatus(ftHandle[i], &dwRxSize); // show progress if (dwRxSize > dwRxSizeTemp) { dwRxSizeTemp = dwRxSize; printf("Buffer %d/%d\n", dwRxSize, BUF_SIZE); } } // buffer is filled if (ftStatus == FT_OK) { // preset buffer pcBufRead = realloc(pcBufRead, dwRxSize); memset(pcBufRead, 0xFF, dwRxSize); /* printf("Calling FT_Read with this read-buffer (prefilled, initializied):\n"); dumpBuffer(pcBufRead, dwRxSize, 1); */ ftStatus = FT_Read(ftHandle[i], pcBufRead, dwRxSize, &dwBytesRead); if (ftStatus != FT_OK) { printf("Error FT_Read(%d)\n", (int) ftStatus); break; } if (dwBytesRead != dwRxSize) { printf("FT_Read only read %d (of %d) bytes\n", (int) dwBytesRead, (int) dwRxSize); break; } printf("FT_Read read %d bytes. Read-buffer is now:\n", (int) dwBytesRead); printf("list in hex"); dumpBuffer(pcBufRead, (int) dwBytesRead, 1); printf("list in hex"); dumpBuffer(pcBufRead, (int) dwBytesRead, 2); printf("list in dec"); dumpBuffer(pcBufRead, (int) dwBytesRead, 3); printf("list in combined"); dumpBuffer(pcBufRead, (int) dwBytesRead, 4); /* if (0 != memcmp(cBufWrite, pcBufRead, BUF_SIZE)) { printf("Error: read-buffer does not match write-buffer.\n"); break; } printf("%s test passed.\n", cBufLD[i]); */ } else { printf("Error FT_GetQueueStatus(%d)\n", (int) 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); printf("Program end.\n"); return 0; }