自学教程：C++ FT_Close函数代码示例

int main(int argc, char *argv[]){	unsigned char * pucUAdata;	DWORD 	dwUASize, dwUARead;	FILE * fp;	FT_HANDLE	ftHandle0;	FT_STATUS	ftStatus;	int iport;		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) {		printf("ftHandle0 = %p/n", ftHandle0);	}	else {		/* 			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_EE_UASize(ftHandle0, &dwUASize);	if(ftStatus == FT_OK)		printf("dwUASize = %d/n", (int)dwUASize);	else {		printf("Could not read UA size/n");		FT_Close(ftHandle0);		return 1;	}	pucUAdata = (unsigned char *)malloc(dwUASize);	if(pucUAdata == NULL) {		printf("Out of resources/n");		FT_Close(ftHandle0);		return 1;	}	ftStatus = FT_EE_UARead(ftHandle0, pucUAdata, dwUASize, &dwUARead);	if(ftStatus == FT_OK) {		fp = fopen("UA_DATA.bin", "w+");		fwrite(pucUAdata, 1, dwUARead, fp);		fclose(fp);	}	else{		printf("could not read UA/n");	}	free(pucUAdata);	FT_Close(ftHandle0);	return 0;}

int main(void){             FT_HANDLE FT_handle; // handle to FT 232 chip    FT_STATUS FT_status; // status of the FT 232 chip    UCHAR Mask;     // for selecting which pins are input/output    UCHAR Mode;     // Selects the mode of operation for the chip            UCHAR UpperNibble_Direction; //whether port is input/output    UCHAR LowerNibble_Data;      // 4 bit data to be sent    UpperNibble_Direction = 0xF0; // setting the direction nibble    LowerNibble_Data      = 0x0F; // setting the data nibble    Mask =  UpperNibble_Direction | LowerNibble_Data;//OR'ing    FT_status = FT_Open(0,&FT_handle); // Open a connection to FT232RL    Mode = 0x20;   // Select Chip mode as CBUS Bit Bang            FT_status = FT_SetBitMode(FT_handle,Mask,Mode);  // Opening  Bit Bang Mode	getchar();		Mode = 0x00; // Reset the chip	Mask = 0x00; // 	FT_status = FT_SetBitMode(FT_handle,Mask,Mode); //Bring back the chip to default mode 	    FT_Close(FT_handle);//Close the connection}

int nifalcon_close(falcon_device* dev){	if(!dev->is_open) nifalcon_error_return(NIFALCON_DEVICE_NOT_FOUND_ERROR, "tried to close an unopened device");	dev->is_open = 0;	FT_Close(dev->falcon);	return 0;}

static int ublast_ftd2xx_quit(struct ublast_lowlevel *low){	FT_HANDLE *ftdih = ublast_getftdih(low);	FT_Close(*ftdih);	return ERROR_OK;}

int gecko_opendevice(){	// Open by Serial Number	status = FT_OpenEx("GECKUSB0", FT_OPEN_BY_SERIAL_NUMBER, &fthandle);	if(status != FT_OK){		eprintf("Error: Couldn't connect to USB Gecko. Please check Installation/n");		return 0;	}	// Reset the Device	status = FT_ResetDevice(fthandle);	if(status != FT_OK){		eprintf("Error: Couldnt Reset Device %d/n",status);		status = FT_Close(fthandle);		return 0;	}	// Set a 3 second timeout for this example	status = FT_SetTimeouts(fthandle,3000,3000);	if(status != FT_OK){		eprintf("Error: Timeouts failed to set %d/n",status);		status = FT_Close(fthandle);		return 0;	}	// Purge RX buffer	status = FT_Purge(fthandle,FT_PURGE_RX);	if(status != FT_OK){		eprintf("Error: Problem clearing buffers %d/n",status);		status = FT_Close(fthandle);		return 0;	}	// Purge TX buffer	status = FT_Purge(fthandle,FT_PURGE_TX);	if(status != FT_OK){		eprintf("Error: Problem clearing buffers %d/n",status);		status = FT_Close(fthandle);		return 0;	}	// Set packet size in bytes - 65536 packet is maximum packet size (USB 2.0)	status = FT_SetUSBParameters(fthandle,65536,0);	if(status != FT_OK){		eprintf("Error: Couldnt Set USB Parameters %d/n",status);		status = FT_Close(fthandle);		return 0;	}	// take breath	sleep(1);	return 1;}

void dxl_hal_close(){	if( ghFt_Handle != 0 )	{		FT_Close( ghFt_Handle );		ghFt_Handle = 0;	}}

VOID CDriverInterface::Cleanup(){    if (m_FTHandle)    {        FT_Close(m_FTHandle);        m_FTHandle = NULL;    }}

/**    Close a power meter probe    /param pm a pointer to a pm_context    /retval  0 - all fine    /retval -1 - invalid pm_context*/PM600X_EXPORT int pm_close(struct pm_context *pm){	if (!pm->handle)		pm_error_return(-1, "invalid pm_context");	FT_Close(pm->handle);	return pm_init(pm);}

/* * Class:     kinetic_Kinetic1090Puck * Method:    puckClose * Signature: ()I */JNIEXPORT jint JNICALL Java_kinetic_Kinetic1090Puck_puckClose(JNIEnv * env, jobject obj){    FT_STATUS ftStatus = FT_Close(ftHandle);    if (ftStatus != FT_OK) {        return -1;    }    return 0;}

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);}

static voidserial_close (){  ProgramMode (0);  Reset (1);  /* >3 mSec reset pulse */  usleep(3*1000);  Reset (0);  FT_Close (handle);}

Dynamixel::~Dynamixel(){    if(initialized_){        FT_STATUS ftStatus = FT_Close(ftHandleDYNA_);        if (ftStatus != FT_OK){            emit failedToClose();        }else{            emit closed();        }    }}

bool FTDXXDevice::disconnect () throw (){  if (!_initialized) return false;  _initialized = false;  FTDLOG("Closing FTDI bus.");#ifdef FOUND_ftd2xx  FT_Close(_handle);  FXXCHECK("Unable to close handle.");#endif  return true;}

int CKMotionIO::Disconnect(){	Mutex->Lock();		m_Connected=false;		FT_Close(ftHandle);		Mutex->Unlock();	return 0;}

void TellStick::rebootTellStick() {	FT_STATUS ftStatus = FT_SetBitMode(d->ftHandle, 0xff, 0x20);	for (int i = 0; i < 100; ++i) {		msleep(1);		QApplication::processEvents();	}	ftStatus = FT_SetBitMode(d->ftHandle, 0xf0, 0x20);	FT_Close(d->ftHandle);	QApplication::processEvents();	setUpgradeStep(5);	QTimer::singleShot(0, this, SLOT(connectTellStick()));}

/*	This is the main reader thread - continually waits for a read*/void *read_watch(void *pArgs){	char buf[20];	DWORD dwRet;	FT_STATUS ftStatus;			while(exit_reader != 1) {//		printf("Write/n");		FT_Write(ftHandle, buf, 20, &dwRet);//		sleep(1);		}	FT_Close(ftHandle);}

int main(int argc, char *argv[]){	DWORD dwBytesInQueue = 0;	EVENT_HANDLE eh;	FT_STATUS	ftStatus;	FT_HANDLE	ftHandle;	int iport;		if(argc > 1) {		sscanf(argv[1], "%d", &iport);	}	else {		iport = 0;	}		pthread_mutex_init(&eh.eMutex, NULL);	pthread_cond_init(&eh.eCondVar, NULL);		ftStatus = FT_Open(iport, &ftHandle);	if(ftStatus != FT_OK) {		/* 			This can fail if the ftdi_sio driver is loaded		 	use lsmod to check this and rmmod ftdi_sio to remove			also rmmod usbserial		 */		printf("FT_Open(%d) failed/n", iport);		return 1;	}			ftStatus = FT_SetFlowControl(ftHandle, FT_FLOW_NONE, 0, 0);	if(ftStatus != FT_OK) {		printf("Failed to set flow control/n");		}	ftStatus = FT_SetEventNotification(ftHandle, FT_EVENT_RXCHAR, (PVOID)&eh);	if(ftStatus != FT_OK) {		printf("Failed to set events/n");		return 1;	}		pthread_mutex_lock(&eh.eMutex);	pthread_cond_wait(&eh.eCondVar, &eh.eMutex);	pthread_mutex_unlock(&eh.eMutex);		FT_GetQueueStatus(ftHandle, &dwBytesInQueue);	printf("Received chars %d bytes in queue/n", (int)dwBytesInQueue);		FT_Close(ftHandle);		return 0;}

static int presto_close(void){	int result = ERROR_OK;#if BUILD_PRESTO_FTD2XX == 1	DWORD ftbytes;	if (presto->handle == (FT_HANDLE)INVALID_HANDLE_VALUE)		return result;	presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX);	if (presto->status != FT_OK)		result = 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))		result = ERROR_JTAG_DEVICE_ERROR;	presto->status = FT_SetLatencyTimer(presto->handle, 16);	if (presto->status != FT_OK)		result = ERROR_JTAG_DEVICE_ERROR;	presto->status = FT_Close(presto->handle);	if (presto->status != FT_OK)		result = ERROR_JTAG_DEVICE_ERROR;	else		presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE;#elif BUILD_PRESTO_LIBFTDI == 1	presto->retval = ftdi_write_data(&presto->ftdic, presto_init_seq, sizeof(presto_init_seq));	if (presto->retval != sizeof(presto_init_seq))		result = ERROR_JTAG_DEVICE_ERROR;	presto->retval = ftdi_set_latency_timer(&presto->ftdic, 16);	if (presto->retval < 0)		result = ERROR_JTAG_DEVICE_ERROR;	presto->retval = ftdi_usb_close(&presto->ftdic);	if (presto->retval < 0)		result = ERROR_JTAG_DEVICE_ERROR;	else		ftdi_deinit(&presto->ftdic);#endif	return result;}

int gecko_sendbyte(unsigned char Textbyte){	unsigned int ret = 0;	ret = gecko_writebyte(&cmd_sendbyte, 1, &TxSent);	if(ret == 0 || ret == 2) {		eprintf("Couldn't send the command to console, check DOL is loaded and connection/n");		status = FT_Close(fthandle);		return 0;	}	gecko_writebyte(&Testbyte, 1, &TxSent);  // Send byte	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;}

//*****************************************************//* Name:			pinddrvDeInit//* Purpose://* In://* Out://*****************************************************void pinddrvDeInit(void){	if(enabled)	{#ifdef PINDMD2		usb_release_interface( device, MY_INTF );		usb_close( device );#else		// have to reset bitbangmode or the ftdi chip will flood the serial with '[00]'		FT_SetBitMode(ftHandle, 0x00, 0x0);		FT_Close(ftHandle);#endif	}}

/** * Запись в порт Б микросхемы ftdi */void FtdiDevices::writeToPortB( char  data ){  DWORD BytesWritten;  /* Запись в лог сообщения */  appLogger.sendDataToViewer( appLogger.INFO_MSG_TYPE, " Исполнение операции записи (WRITE_PORTB) ", appLogger.SYSTEM_LOGGER );  if ( listPorts.size() > -1 ) {    ftStatus = FT_Open( 1 /* Порт Б */, &m_ftHandleB );    if ( ftStatus != FT_OK ) {      /* Запись в лог сообщения */      appLogger.sendDataToViewer( appLogger.ERROR_MSG_TYPE," Операция открытия порта не выполнена! ", appLogger.SYSTEM_LOGGER );    }    else {      /* Запись в лог сообщения */      appLogger.sendDataToViewer( appLogger.INFO_MSG_TYPE," Операция открытия порта выполнена! ", appLogger.SYSTEM_LOGGER );    }    ftStatus = FT_SetBitMode( m_ftHandleB, 0xFE, 0x01 );    if ( ftStatus == FT_OK ) {      /* Запись в лог сообщения */      appLogger.sendDataToViewer( appLogger.INFO_MSG_TYPE," Операция установки bitbang порта выполнена! ", appLogger.SYSTEM_LOGGER );    } else {      /* Запись в лог сообщения */      appLogger.sendDataToViewer( appLogger.ERROR_MSG_TYPE," Операция установки bitbang порта не выполнена! ", appLogger.SYSTEM_LOGGER );    }    ftStatus = FT_Write( m_ftHandleB, &data, 1, &BytesWritten );    if ( ftStatus != FT_OK ) {      /* Запись в лог сообщения */      appLogger.sendDataToViewer( appLogger.ERROR_MSG_TYPE," Операция записи в порт не выполнена! ", appLogger.SYSTEM_LOGGER );;    }    else {      /* Запись в лог сообщения */      appLogger.sendDataToViewer( appLogger.INFO_MSG_TYPE," Операция записи в порт выполнена! ", appLogger.SYSTEM_LOGGER );    }     FT_Close( m_ftHandleB );     if ( ftStatus != FT_OK ) {       /* Запись в лог сообщения */       appLogger.sendDataToViewer( appLogger.ERROR_MSG_TYPE," Операция закрытия порта не выполнена! ", appLogger.SYSTEM_LOGGER );     }     else {       /* Запись в лог сообщения */       appLogger.sendDataToViewer( appLogger.INFO_MSG_TYPE," Операция закрытия порта выполнена! ", appLogger.SYSTEM_LOGGER );     }  }}

int closeSerialPorts() {  int i;  FT_STATUS	ftStatus;  /* Cleanup */  for(i = 0; i < foundDevices; i++) {    if((ftStatus = FT_SetDataCharacteristics(ftHandle[i], FT_BITS_8, FT_STOP_BITS_1, FT_PARITY_NONE)) != FT_OK) {      printf("Error FT_SetDataCharacteristics(%d) = %s/n", ftStatus, cBufLD[i]);      break;    }    FT_Close(ftHandle[i]);    printf("Closed device %s/n", cBufLD[i]);  }  return 0;}

int gecko_readbyte(LPVOID lpBuffer, DWORD dwBytesToRead, LPDWORD lpdwBytesReturned){        // read data based on FTDI D2XX USB 2.0 API        status = FT_Read(fthandle, lpBuffer, dwBytesToRead, lpdwBytesReturned);        if (status == FT_OK) {                if(*lpdwBytesReturned != dwBytesToRead)                        return 2;        } else {                eprintf("Error: Read Error. Closing/n");                status = FT_Close(fthandle);                return 0;        }        return 1;}

/**************************************************************************** Function    : TCclose() Description : Close FTDI connection and free any data previously allocated               by the library. Parameters  : None (void). Returns     : Nothing (void). ****************************************************************************/void TCclose(void){	if(ftdiHandle)	{		FT_Close(ftdiHandle);		ftdiHandle   = NULL;	}	if(pixelCurrent)	{		free(pixelCurrent);		pixelCurrent   = NULL;		pixelOutBuffer = NULL;	}	nStrands        = 0;	pixelsPerStrand = 0;}

int gecko_writebyte(LPVOID lpBuffer, DWORD dwBytesToWrite, LPDWORD lpdwBytesWritten){        // write data based on FTDI D2XX USB 2.0 API        status = FT_Write(fthandle, lpBuffer, dwBytesToWrite, lpdwBytesWritten);        if (status == FT_OK) {                if(*lpdwBytesWritten != dwBytesToWrite)			return 2;      // Can be used for packet retry code ect        } else {                eprintf("Error: Write Error. Closing./n");                status = FT_Close(fthandle);                            // Close device if fatal error                return 0;        }	// Packet Sent        return 1;}

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");		}	}}