void readCBuSbits(void)
{
ftStatus = FT_EE_Read(ftHandle, &ftData);
if (ftStatus == FT_OK) {
printf(" CBUS0 = 0X%02X\n", ftData.Cbus0);
printf(" CBUS1 = 0X%02X\n", ftData.Cbus1);
printf(" CBUS2 = 0X%02X\n", ftData.Cbus2);
printf(" CBUS3 = 0X%02X\n", ftData.Cbus3);
printf(" CBUS4 = 0X%02X\n", ftData.Cbus4);
}
else
{
printf("Failed Reading status o Cbus pins! \n");
}
}
void setCBUSbits(UCHAR cbus1)
{
ftStatus = FT_Open(i,&ftHandle);
ftStatus = FT_EE_Read(ftHandle, &ftData);
if (ftStatus == FT_OK) {
old_cbus1_state=ftData.Cbus1; // save state of cbus1
// ftData.Cbus0=0;
ftData.Cbus1 = cbus1; // 0x0A will set to I/O mode, otherwise restore from old_cbus1_state
// ftData.Cbus2=1;
// ftData.Cbus3=2;
// ftData.Cbus4=1;
ftStatus = FT_EE_Program(ftHandle, &ftData);
if (ftStatus == FT_OK)
{
ftStatus = FT_CyclePort(ftHandle);
if (ftStatus == FT_OK)
{
// Port has been cycled.
// Close the handle.
ftStatus = FT_Close(ftHandle);
if (ftStatus==FT_OK) {
printf("Device Close OK! \n");
ftStatus=FT_Rescan();
Sleep(5000);
}
else
{
printf("Device Close Failed! \n");
}
}
else
{
// FT_CyclePort FAILED!
printf("CyclePort Failed!\n");
}
}
else
{
// FT_EE_Program FAILED!
printf("FT_EE_Program FAILED!\n");
}
}
}
/* Writing data to EEPROM FTDI */
quint16 ftdiChip::on_EEPROM()
{
FT_STATUS ftStatus;
FT_PROGRAM_DATA ftData;
char ManufacturerBuf[32];
char ManufacturerIdBuf[16];
char DescriptionBuf[64];
char SerialNumberBuf[16];
memset(&ftData,0,sizeof(ftData));
ftData.Signature1 = 0x00000000;
ftData.Signature2 = 0xffffffff;
ftData.Version = 0x00000002; // EEPROM structure with FT232R extensions */
ftData.Manufacturer = ManufacturerBuf;
ftData.ManufacturerId = ManufacturerIdBuf;
ftData.Description = DescriptionBuf;
ftData.SerialNumber = SerialNumberBuf;
ftStatus = Open();
if(ftStatus==retOk){
ftStatus = FT_EE_Read(hdUSB, &ftData);
if (ftStatus != FT_OK) {
emit signalStatusError(tr("Failed to open USB port"),true);
return retErr;
}
strcpy(ftData.Manufacturer,"ELINTEL");
strcpy(ftData.ManufacturerId,"FT");
strcpy(ftData.Description,"Debag_for_UDZ");
strcpy(ftData.SerialNumber,"FT000001");
ftData.Cbus0 = 0x0A;
ftData.Cbus1 = 0x0A;
ftData.Cbus2 = 0x00;
ftData.Cbus3 = 0x0A;
ftData.Cbus4 = 0x01;
ftStatus = FT_EE_Program(hdUSB, &ftData);
if (ftStatus != FT_OK){
emit signalStatusError(tr("Error writing flash"),true);
return retErr;
}
emit signalStatusOk(tr("Flash is successfully"));
return retOk;
}
emit signalStatusError(tr("Error writing flash"),true);
return retErr;
}
/**
* Get some interesting strings from the device.
*
* @param deviceIndex The device index, whose strings to get
* @param vendor Returned vendor string
* @param description Returned description string
* @param serial Returned serial string
* @return FT_OK if strings were extracted successfully
*/
static FT_STATUS get_interface_info(DWORD deviceIndex,
QString& vendor, QString& description,
QString& serial, quint16 &VID, quint16 &PID)
{
char cVendor[256];
char cVendorId[256];
char cDescription[256];
char cSerial[256];
FT_HANDLE handle;
FT_STATUS status = FT_Open(deviceIndex, &handle);
if (status != FT_OK)
return status;
FT_PROGRAM_DATA pData;
pData.Signature1 = 0;
pData.Signature2 = 0xFFFFFFFF;
pData.Version = 0x00000005;
pData.Manufacturer = cVendor;
pData.ManufacturerId = cVendorId;
pData.Description = cDescription;
pData.SerialNumber = cSerial;
status = FT_EE_Read(handle, &pData);
if (status == FT_OK)
{
VID = pData.VendorId;
PID = pData.ProductId;
if (pData.ProductId == DMXInterface::DMX4ALLPID)
vendor = QString("DMX4ALL");
else
vendor = QString(cVendor);
description = QString(cDescription);
serial = QString(cSerial);
}
FT_Close(handle);
return status;
}
int getandcheckCBUS( FT_HANDLE ftHandle0 ) {
FT_PROGRAM_DATA Data;
int need_write = 0;
FT_STATUS ftStatus;
if( ser_dbg )
printf("ftHandle0 = %p\n", ftHandle0);
Data.Signature1 = 0x00000000;
Data.Signature2 = 0xffffffff;
Data.Manufacturer = (char *)malloc(256); // "FTDI"
Data.ManufacturerId = (char *)malloc(256); // "FT"
Data.Description = (char *)malloc(256); // "USB HS Serial Converter"
Data.SerialNumber = (char *)malloc(256); // "FT000001" if fixed, or NULL
ftStatus = FT_EE_Read(ftHandle0, &Data);
if(ftStatus != FT_OK) {
printf("FT_EE_Read failed\n");
FT_Close(ftHandle0);
return 1;
}
if( ser_dbg ) {
printf("Cbus0 = 0x%X\n", Data.Cbus0); // Cbus Mux control
printf("Cbus1 = 0x%X\n", Data.Cbus1); // Cbus Mux control
printf("Cbus2 = 0x%X\n", Data.Cbus2); // Cbus Mux control
printf("Cbus3 = 0x%X\n", Data.Cbus3); // Cbus Mux control
printf("Cbus4 = 0x%X\n", Data.Cbus4); // Cbus Mux control
}
// check that cbus0 and 2 are write
if( Data.Cbus0 != 0x0A ) {
printf( "Cbus0 is %d, should be %d, updating!\n", Data.Cbus0, 0xA );
Data.Cbus0 = 0x0A;
need_write = 1;
}
if( Data.Cbus2 != 0x0A ) {
printf( "Cbus2 is %d, should be %d, updating!\n", Data.Cbus2, 0xA );
Data.Cbus2 = 0x0A;
need_write = 1;
}
// check that CBUS3 is power enable
if( Data.Cbus3 != 0x0A ) { // was 01
printf( "Cbus3 is %d, should be %d, updating!\n", Data.Cbus3, 0x1);
//Data.Cbus2 = 0x0B; // wierd, should be writing to cbus3, has no effect because current verion is alwasy default (0x01)
Data.Cbus3 = 0x0A;
need_write = 1;
}
// not necessary, but for the hell of it, cbus 1 is read
if( Data.Cbus1 != 0x0A ) {
printf( "Cbus1 is %d, should be %d, updating!\n", Data.Cbus1, 0xA );
Data.Cbus1 = 0x0A;
need_write = 1;
}
if( need_write ) {
printf( "Updating EEPROM to correct setting for safecast.\n" );
ftStatus = FT_EE_Program(ftHandle0, &Data);
if(ftStatus != FT_OK) {
printf("FT_EE_Program failed (%d)\n", ftStatus);
FT_Close(ftHandle0);
return 1;
}
printf( "------> Now that the EEPROM is updated, unplug and replug the device.\n" );
} else {
printf( "EEPROM values are up to date, not modifying them\n" );
}
printf( "Updating CBUS3 for charging.\n" );
ftStatus = FT_SetBitMode(ftHandle0, 0x80, 0x20); // CBUS bitbang mode
if(ftStatus != FT_OK) {
printf("Failed to set CBUS\n");
}else {
printf("Set CBUS3 to LOW\n" );
}
return 0;
}
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);
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);
Data.Signature1 = 0x00000000;
Data.Signature2 = 0xffffffff;
Data.Manufacturer = (char *)malloc(256); // "FTDI"
Data.ManufacturerId = (char *)malloc(256); // "FT"
Data.Description = (char *)malloc(256); // "USB HS Serial Converter"
Data.SerialNumber = (char *)malloc(256); // "FT000001" if fixed, or NULL
ftStatus = FT_EE_Read(ftHandle0, &Data);
if(ftStatus != FT_OK) {
printf("FT_EE_Read failed\n");
FT_Close(ftHandle0);
return 1;
}
FT_Close(ftHandle0);
printf("Signature1 = %d\n", Data.Signature1);
printf("Signature2 = %d\n", Data.Signature2);
printf("Version = %d\n", Data.Version);
printf("VendorId = 0x%04X\n", Data.VendorId);
printf("ProductId = 0x%04X\n", Data.ProductId);
printf("Manufacturer = %s\n", Data.Manufacturer);
printf("ManufacturerId = %s\n", Data.ManufacturerId);
printf("Description = %s\n", Data.Description);
printf("SerialNumber = %s\n", Data.SerialNumber);
printf("MaxPower = %d\n", Data.MaxPower);
printf("PnP = %d\n", Data.PnP) ;
printf("SelfPowered = %d\n", Data.SelfPowered);
printf("RemoteWakeup = %d\n", Data.RemoteWakeup);
//
// Rev4 extensions
//
printf("Rev4 = 0x%X\n", Data.Rev4);
printf("IsoIn = 0x%X\n", Data.IsoIn);
printf("IsoOut = 0x%X\n", Data.IsoOut);
printf("PullDownEnable = 0x%X\n", Data.PullDownEnable);
printf("SerNumEnable = 0x%X\n", Data.SerNumEnable);
printf("USBVersionEnable = 0x%X\n", Data.USBVersionEnable);
printf("USBVersion = 0x%X\n", Data.USBVersion);
//
// FT2232C extensions
//
printf("Rev5 = 0x%X\n", Data.Rev5);
printf("IsoInA = 0x%X\n", Data.IsoInA);
printf("IsoInB = 0x%X\n", Data.IsoInB);
printf("IsoOutA = 0x%X\n", Data.IsoOutA);
printf("IsoOutB = 0x%X\n", Data.IsoOutB);
printf("PullDownEnable5 = 0x%X\n", Data.PullDownEnable5);
printf("SerNumEnable5 = 0x%X\n", Data.SerNumEnable5);
printf("USBVersionEnable5 = 0x%X\n", Data.USBVersionEnable5);
printf("USBVersion5 = 0x%X\n", Data.USBVersion5);
printf("AIsHighCurrent = 0x%X\n", Data.AIsHighCurrent);
printf("BIsHighCurrent = 0x%X\n", Data.BIsHighCurrent);
printf("IFAIsFifo = 0x%X\n", Data.IFAIsFifo);
printf("IFAIsFifoTar = 0x%X\n", Data.IFAIsFifoTar);
printf("IFAIsFastSer = 0x%X\n", Data.IFAIsFastSer);
printf("AIsVCP = 0x%X\n", Data.AIsVCP);
printf("IFBIsFifo = 0x%X\n", Data.IFBIsFifo);
printf("IFBIsFifoTar = 0x%X\n", Data.IFBIsFifoTar);
printf("IFBIsFastSer = 0x%X\n", Data.IFBIsFastSer);
printf("BIsVCP = 0x%X\n", Data.BIsVCP);
//
// FT232R extensions
//
printf("UseExtOsc = 0x%X\n", Data.UseExtOsc); // Use External Oscillator
printf("HighDriveIOs = 0x%X\n", Data.HighDriveIOs); // High Drive I/Os
printf("EndpointSize = 0x%X\n", Data.EndpointSize); // Endpoint size
printf("PullDownEnableR = 0x%X\n", Data.PullDownEnableR); // non-zero if pull down enabled
printf("SerNumEnableR = 0x%X\n", Data.SerNumEnableR); // non-zero if serial number to be used
printf("InvertTXD = 0x%X\n", Data.InvertTXD); // non-zero if invert TXD
printf("InvertRXD = 0x%X\n", Data.InvertRXD); // non-zero if invert RXD
printf("InvertRTS = 0x%X\n", Data.InvertRTS); // non-zero if invert RTS
printf("InvertCTS = 0x%X\n", Data.InvertCTS); // non-zero if invert CTS
printf("InvertDTR = 0x%X\n", Data.InvertDTR); // non-zero if invert DTR
printf("InvertDSR = 0x%X\n", Data.InvertDSR); // non-zero if invert DSR
printf("InvertDCD = 0x%X\n", Data.InvertDCD); // non-zero if invert DCD
printf("InvertRI = 0x%X\n", Data.InvertRI); // non-zero if invert RI
printf("Cbus0 = 0x%X\n", Data.Cbus0); // Cbus Mux control
printf("Cbus1 = 0x%X\n", Data.Cbus1); // Cbus Mux control
printf("Cbus2 = 0x%X\n", Data.Cbus2); // Cbus Mux control
printf("Cbus3 = 0x%X\n", Data.Cbus3); // Cbus Mux control
printf("Cbus4 = 0x%X\n", Data.Cbus4); // Cbus Mux control
printf("RIsVCP = 0x%X\n", Data.RIsVCP); // non-zero if using VCP drivers
free(Data.Manufacturer);
free(Data.ManufacturerId);
free(Data.Description);
free(Data.SerialNumber);
return 0;
}
bool CMmcUsbHndlBase::EE_Program( unsigned short p_usVendorId,
unsigned short p_usProductId,
char* p_pManufacturer,
unsigned int p_ulManufacturerLength,
char* p_pDescription,
unsigned int p_ulDescriptionLength,
char* p_pSerialNumber,
unsigned int p_ulSerialNumberLength,
bool p_oUseVcpDriver)
{
const unsigned int BUFFER_SIZE(64);
FT_PROGRAM_DATA ftData;
TCHAR ManufacturerBuf[BUFFER_SIZE];
TCHAR ManufacturerIdBuf[BUFFER_SIZE];
TCHAR DescriptionBuf[BUFFER_SIZE];
TCHAR SerialNumberBuf[BUFFER_SIZE];
BOOL oResult(FALSE);
FT_STATUS ftStatus = FT_OK;
//ResetErrorInfo
//m_ErrorInfo.Reset();
//Prepare Structure
ftData.Signature1 = 0x00000000;
ftData.Signature2 = 0xffffffff;
ftData.Version = 0x00000002; // EEPROM structure with FT232R extensions
ftData.Manufacturer = ManufacturerBuf;
ftData.ManufacturerId = ManufacturerIdBuf;
ftData.Description = DescriptionBuf;
ftData.SerialNumber = SerialNumberBuf;
//Read EE
if(FT_OK == (ftStatus = FT_EE_Read(m_Handle, &ftData)))
{
//VendorId
ftData.VendorId = p_usVendorId;
//ProductId
ftData.ProductId = p_usProductId;
//Manufacturer
if(p_ulManufacturerLength < BUFFER_SIZE)
{
memset(ManufacturerBuf, 0, BUFFER_SIZE*sizeof(char));
if(p_pManufacturer) strcpy(ManufacturerBuf, p_pManufacturer);
}
//Description
if(p_ulDescriptionLength < BUFFER_SIZE)
{
memset(DescriptionBuf, 0, BUFFER_SIZE*sizeof(TCHAR));
if(p_pDescription) strcpy(DescriptionBuf, p_pDescription);
}
//SerialNumber
if(p_ulSerialNumberLength < BUFFER_SIZE)
{
memset(SerialNumberBuf, 0, BUFFER_SIZE*sizeof(TCHAR));
if(p_pSerialNumber) strcpy(SerialNumberBuf, p_pSerialNumber);
}
//UseVcpDriver
if(p_oUseVcpDriver) ftData.RIsD2XX = 0; else ftData.RIsD2XX = 1;
//Program EE
if(FT_OK == (ftStatus = FT_EE_Program(m_Handle, &ftData)))
oResult = TRUE;
else
{
std::string errormsg = GetFtStatusDescription(ftStatus);
errormsg += ":FT_EE_Program";
perror(errormsg.c_str());
oResult = FALSE;
}
}
else
{
std::string errormsg = GetFtStatusDescription(ftStatus);
errormsg += ":FT_EE_Read";
perror(errormsg.c_str());
oResult = FALSE;
}
return oResult;
}
bool CMmcUsbHndlBase::EE_Read(unsigned short& p_rusVendorId,
unsigned short& p_rusProductId,
char*& p_rpManufacturer,
unsigned int& p_rulManufacturerLength,
char*& p_rpDescription,
unsigned int& p_rulDescriptionLength,
char*& p_rpSerialNumber,
unsigned int& p_rulSerialNumberLength,
bool& p_roUseVcpDriver)
{
const int BUFFER_SIZE(64);
FT_PROGRAM_DATA ftData;
TCHAR ManufacturerBuf[BUFFER_SIZE];
TCHAR ManufacturerIdBuf[BUFFER_SIZE];
TCHAR DescriptionBuf[BUFFER_SIZE];
TCHAR SerialNumberBuf[BUFFER_SIZE];
BOOL oResult(FALSE);
FT_STATUS ftStatus = FT_OK;
//ResetErrorInfo
//m_ErrorInfo.Reset();
//Prepare Structure
ftData.Signature1 = 0x00000000;
ftData.Signature2 = 0xffffffff;
ftData.Version = 0x00000002; // EEPROM structure with FT232R extensions
ftData.Manufacturer = ManufacturerBuf;
ftData.ManufacturerId = ManufacturerIdBuf;
ftData.Description = DescriptionBuf;
ftData.SerialNumber = SerialNumberBuf;
if(FT_OK == (ftStatus = FT_EE_Read(m_Handle, &ftData)))
{
//VendorId
p_rusVendorId = ftData.VendorId;
//ProductId
p_rusProductId = ftData.ProductId;
//Manufacturer
p_rulManufacturerLength = strlen(ManufacturerBuf)+1;
p_rpManufacturer = (char*)malloc(p_rulManufacturerLength*sizeof(char));
memset(p_rpManufacturer, 0, p_rulManufacturerLength*sizeof(char));
strcpy(p_rpManufacturer, ManufacturerBuf);
//Description
p_rulDescriptionLength = strlen(DescriptionBuf)+1;
p_rpDescription = (char*)malloc(p_rulDescriptionLength*sizeof(char));
memset(p_rpDescription, 0, p_rulDescriptionLength*sizeof(char));
strcpy(p_rpDescription, DescriptionBuf);
//SerialNumber
p_rulSerialNumberLength = strlen(SerialNumberBuf)+1;
p_rpSerialNumber = (char*)malloc(p_rulSerialNumberLength*sizeof(char));
memset(p_rpSerialNumber, 0, p_rulSerialNumberLength*sizeof(char));
strcpy(p_rpSerialNumber, SerialNumberBuf);
//UseVcpDriver
if(ftData.RIsD2XX) p_roUseVcpDriver = FALSE; else p_roUseVcpDriver = TRUE;
oResult = TRUE;
}
else
{
std::string errormsg = GetFtStatusDescription(ftStatus);
errormsg += ":FT_EE_Read";
perror(errormsg.c_str());
oResult = FALSE;
}
return oResult;
}
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 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;
}
void get_info(void)
{
UCHAR Mask = 0xff;
UCHAR Mode = 1; // Set asynchronous bit-bang mode
LONG lComPortNumber;
DWORD numDevs;
//UCHAR BitMode;
char ManufacturerBuf[32];
char ManufacturerIdBuf[16];
char DescriptionBuf[64];
char SerialNumberBuf[16];
ftData.Signature1 = 0x00000000;
ftData.Signature2 = 0xffffffff;
ftData.Version = 0x00000002;
ftData.Manufacturer = ManufacturerBuf;
ftData.ManufacturerId = ManufacturerIdBuf;
ftData.Description = DescriptionBuf;
ftData.SerialNumber = SerialNumberBuf;
ftStatus = FT_CreateDeviceInfoList(&numDevs);
if (ftStatus == FT_OK)
{
printf("Number of devices is %d\n",numDevs);
}
if (numDevs > 0)
{
// allocate storage for list based on numDevs
devInfo = (FT_DEVICE_LIST_INFO_NODE*)malloc(sizeof(FT_DEVICE_LIST_INFO_NODE)*numDevs); // get the device information list
ftStatus = FT_GetDeviceInfoList(devInfo,&numDevs);
if (ftStatus == FT_OK)
{
for (i = 0; i < numDevs; i++)
{
printf("Dev %d:\n",i);
printf(" Flags=0x%x\n",devInfo[i].Flags);
printf(" Type=%s\n",devices[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);
}
}
i=0; //open first device
ftStatus = FT_Open(i,&ftHandle);
if (ftStatus != FT_OK)
{
printf("Can't open %s device! \n",devInfo[i].Description);
}
else
{
printf("Successfully open %s device! \n",devInfo[i].Description);
ftStatus = FT_GetComPortNumber(ftHandle,&lComPortNumber);
if (ftStatus == FT_OK)
{
if (lComPortNumber == -1)
{
printf(" NO com port Assigned!\n");
}
else
{
// COM port assigned with number held in lComPortNumber
printf(" Current assigned COM Port: %d \n",lComPortNumber);
}
}
else
{
printf(" Failed to get the COM Port!\n");
}
ftStatus = FT_EE_Read(ftHandle, &ftData);
if (ftStatus == FT_OK)
{
// FT_EE_Read OK, data is available in ftData
printf(" EEPROM READ OK\n");
printf("Signature1 = 0x%04x\n", ftData.Signature1);
printf("Signature2 = 0x%04x\n", ftData.Signature2);
printf("Version = 0x%04x\n", ftData.Version);
printf("VendorID = 0x%04x\n", ftData.VendorId);
printf("ProductID = 0x%04x\n", ftData.ProductId);
printf("Manufacturer = %s\n", ftData.Manufacturer);
printf("ManufacturerID = %s\n", ftData.ManufacturerId);
printf("Description = %s\n", ftData.Description);
printf("SerialNumber = %s\n", ftData.SerialNumber);
printf("MaxPower = %d\n", ftData.MaxPower);
printf("PnP = %x\n", ftData.PnP);
printf("SelfPowered = %x\n", ftData.SelfPowered);
printf("RemoteWakeup = %x\n", ftData.RemoteWakeup);
printf("Use Ext Osc = %x\n", ftData.UseExtOsc);
printf("High Drives = %x\n", ftData.HighDriveIOs);
printf("Endpoint Size = %x\n", ftData.EndpointSize);
printf("Pull Down Enabled = %x\n", ftData.PullDownEnableR);
printf("Serial Number Enabled = %x\n", ftData.SerNumEnableR);
printf("Invert TXD = %x\n", ftData.InvertTXD);
printf("Invert RXD = %x\n", ftData.InvertRXD);
printf("Invert RTS = %x\n", ftData.InvertRTS);
printf("Invert CTS = %x\n", ftData.InvertCTS);
printf("Invert DTR = %x\n", ftData.InvertDTR);
printf("Invert DSR = %x\n", ftData.InvertDSR);
printf("Invert DCD = %x\n", ftData.InvertDCD);
printf("Invert RI = %x\n", ftData.InvertRI);
printf("CBUS0 = 0X%02X\n", ftData.Cbus0);
printf("CBUS1 = 0X%02X\n", ftData.Cbus1);
printf("CBUS2 = 0X%02X\n", ftData.Cbus2);
printf("CBUS3 = 0X%02X\n", ftData.Cbus3);
printf("CBUS4 = 0X%02X\n", ftData.Cbus4);
}
else
{
// FT_EE_Read FAILED!
printf(" EEPROM READ FAILED\n");
}
FT_Close(ftHandle);
}
}
else
{
printf("No FT232 Device found! \n");
}
}
