/* * use libftdi and libusb to send command * no kernel driver needed */ int usbWriteFtdi(char *cmdstr) { struct ftdi_context ctx; int device=0x0c30, vendor=0x1781; if (ftdi_init( &ctx )) { fprintf(stderr, "usb - init error !\n"); return 1; } if (ftdi_usb_open(&ctx, vendor, device)) { fprintf(stderr, "usb - open error (cannot find?) !\n"); ftdi_deinit( &ctx ); return 2; } if (ftdi_usb_reset( &ctx )) { fprintf(stderr, "usb - reset error !\n"); ftdi_usb_close( &ctx ); ftdi_deinit( &ctx ); return 3; } ftdi_disable_bitbang( &ctx ); ftdi_set_baudrate(&ctx, BAUD); ftdi_write_data( &ctx, cmdstr, strlen(cmdstr) ); sleep(1); /* just for sure */ ftdi_usb_close( &ctx ); ftdi_deinit( &ctx ); return 0; }
ReturnCode reader_connect(struct reader *reader, int beep) { ReturnCode rc; if(reader->ftdic == NULL || reader->dev == NULL) { printf("reader entry null\n"); return RC_NULL_ERROR; } if(ftdi_usb_open_dev(reader->ftdic, reader->dev) < 0){ printf("ftdi usb open dev failed\n"); return RC_IO_ERROR; } if((rc = reader_reset(reader)) != RC_SUCCESS){ printf("reset failed\n"); ftdi_usb_close(reader->ftdic); return rc; } if((rc = reader_purge(reader)) != RC_SUCCESS){ printf("purge failed\n"); ftdi_usb_close(reader->ftdic); return rc; } if(ftdi_set_baudrate(reader->ftdic, RFID1_BAUDRATE) < 0){ printf("setbaudrate failed\n"); ftdi_usb_close(reader->ftdic); return RC_IO_ERROR; } usleep(10000); if((rc = reader_ping(reader)) != RC_SUCCESS){ ftdi_usb_close(reader->ftdic); return rc; } reader->connected = 1; if(beep) { reader_pass_beep(reader); } return RC_SUCCESS; }
int _ftdi_usb_close(ftdi_context *ftdi){ #ifdef __APPLE__ return ftdi_usb_close(ftdi); #else //Still needed on Ubuntu //Wrapper method due to bug in old libftdi driver //http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00214.html int ret = 0; if (ftdi->usb_dev != NULL){ ret = ftdi_usb_close(ftdi); ftdi->usb_dev = NULL; } return ret; #endif }
void jtagkey_close(int handle) { if (handle == 0xff) { ftdi_disable_bitbang(&ftdic); ftdi_usb_close(&ftdic); ftdi_deinit(&ftdic); } }
int main(int argc, char *argv[] ) { unsigned char fan = 0; char temp = 0; int ret = 0; if(argc != 2){ printf("usage: ux400opm 1/0\n"); exit(0); } if((ret = sys_init())<0) { printf("LIBFTDI init failed, exit\n"); exit(1); } temp = cpldver(); if(temp < 0 ) { printf("Read CPLD version failed, exit\n"); exit(1); } if(atoi(argv[1]) == 1){ opm_pwr(OPM_ON); }else{ opm_pwr(OPM_OFF); } ftdi_usb_close(&ux400_ftdic); ftdi_deinit(&ux400_ftdic); }
bool IntanThread::closeUSB() { ftdi_usb_close(&ftdic); ftdi_deinit(&ftdic); std::cout << "FTDI interface destroyed." << std::endl; return true; }
~Private() { if (open) ftdi_usb_close(ftdi); ftdi_free(ftdi); }
/** * Close the USB port and reset the sequencer logic. * * @param devc The struct containing private per-device-instance data. * * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments. */ static int close_usb_reset_sequencer(struct dev_context *devc) { /* Magic sequence of bytes for resetting the sequencer logic. */ uint8_t buf[8] = {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}; int ret; /* Note: Caller checked that devc and devc->ftdic != NULL. */ if (devc->ftdic->usb_dev) { /* Reset the sequencer logic, then wait 100ms. */ sr_dbg("Resetting sequencer logic."); (void) cv_write(devc, buf, 8); /* Ignore errors. */ g_usleep(100 * 1000); /* Purge FTDI buffers, then reset and close the FTDI device. */ sr_dbg("Purging buffers, resetting+closing FTDI device."); /* Log errors, but ignore them (i.e., don't abort). */ if ((ret = ftdi_usb_purge_buffers(devc->ftdic)) < 0) sr_err("Failed to purge FTDI buffers (%d): %s.", ret, ftdi_get_error_string(devc->ftdic)); if ((ret = ftdi_usb_reset(devc->ftdic)) < 0) sr_err("Failed to reset FTDI device (%d): %s.", ret, ftdi_get_error_string(devc->ftdic)); if ((ret = ftdi_usb_close(devc->ftdic)) < 0) sr_err("Failed to close FTDI device (%d): %s.", ret, ftdi_get_error_string(devc->ftdic)); } /* Close USB device, deinitialize and free the FTDI context. */ ftdi_free(devc->ftdic); devc->ftdic = NULL; return SR_OK; }
// // Close the serial port. // static dc_status_t serial_ftdi_close (void **userdata) { ftdi_serial_t *device = (ftdi_serial_t*) *userdata; if (device == NULL) return DC_STATUS_SUCCESS; // Restore the initial terminal attributes. // See if it is possible using libusb or libftdi int ret = ftdi_usb_close(device->ftdi_ctx); if (ret < 0) { ERROR (device->context, "Unable to close the ftdi device : %d (%s)\n", ret, ftdi_get_error_string(device->ftdi_ctx)); return ret; } ftdi_free(device->ftdi_ctx); // Free memory. free (device); *userdata = NULL; return DC_STATUS_SUCCESS; }
int spectrig_connect(struct ftdi_context *ftdi) { int ret; ftdi_init(ftdi); /* TODO: Be a bit more selective and support multiple devices properly */ ret = open_by_desc_prefix(ftdi, 0x0403, 0x6010, spectrig_descs); if (ret < 0) { perror("Failed to open the device"); return ret; } ftdi_usb_purge_buffers(ftdi); /* Initialize synchronous communication */ ret = ftdi_set_latency_timer(ftdi, 2); if (ret < 0) { perror("Failed to set the latency timer"); goto close; } ret = ftdi_read_data_set_chunksize(ftdi, 0x10000); if (ret < 0) { perror("Failed to set read data chunksize"); goto close; } ret = ftdi_write_data_set_chunksize(ftdi, 0x10000); if (ret < 0) { perror("Failed to write read data chunksize"); goto close; } ret = ftdi_setflowctrl(ftdi, SIO_RTS_CTS_HS); if (ret < 0) { perror("Failed to set flow control"); goto close; } msleep(20); ret = ftdi_set_bitmode(ftdi, 0xff, 0x00); if (ret < 0) { perror("Failed to set bitmode 0x00"); goto close; } msleep(20); ftdi_set_bitmode(ftdi, 0xff, 0x40); if (ret < 0) { perror("Failed to set bitmode 0x40"); goto close; } msleep(300); ftdi_usb_purge_buffers(ftdi); return 0; close: ftdi_usb_close(ftdi); ftdi_deinit(ftdi); return ret; }
GovernorFtdi::~GovernorFtdi() { if(readThread) readThread->shutdown(); ftdi_usb_close(&ftdic); ftdi_deinit(&ftdic); ftdic.usb_dev = NULL; }
static int ublast_ftdi_quit(struct ublast_lowlevel *low) { struct ftdi_context *ftdic = ublast_getftdic(low); ftdi_usb_close(ftdic); ftdi_deinit(ftdic); return ERROR_OK; };
ReturnCode reader_disconnect(struct reader *reader) { if(!reader->connected) return RC_NOT_CONNECTED; reader->connected = 0; if(ftdi_usb_close(reader->ftdic) < 0){ return RC_IO_ERROR; } return RC_SUCCESS; }
int nifalcon_close(falcon_device* dev) { if(!dev->is_initialized) nifalcon_error_return(NIFALCON_DEVICE_NOT_VALID_ERROR, "tried to close an uninitialized device"); if(!dev->is_open) nifalcon_error_return(NIFALCON_DEVICE_NOT_FOUND_ERROR, "tried to close an unopened device"); if((dev->falcon_status_code = ftdi_usb_close(&(dev->falcon))) < 0) return dev->falcon_status_code; dev->is_open = 0; return 0; }
void ftdi_close() { if(ftdi_usb_close(&ftdi)!=0) printf("\nusb could not be closed.\n"); else printf("\nusb closed.\n"); ftdi_deinit(&ftdi); }
FtdiWrapper::~FtdiWrapper() { //close connection int rtn = ftdi_usb_close(ftdiContext); if(rtn < 0) cerr << ftdi_get_error_string(ftdiContext) << endl; //free connection context ftdi_free(ftdiContext); }
OBDDevice::~OBDDevice() { QMutexLocker locker( &obdMutex ); /* Release the FTDI context */ ftdi_usb_close( ftdi ); ftdi_free( ftdi ); qDebug() << "~OBDDevice()"; }
void release(void) { if(ftdi) { ftdi_disable_bitbang(ftdi); ftdi_usb_close(ftdi); ftdi_free(ftdi); ftdi = NULL; } }
bool FTDIDevice::disconnect () throw () { if (!_initialized) return false; _initialized = false; FTDLOG("Closing FTDI bus."); #ifdef FOUND_ftdi ftdi_usb_close(&_ftdic); #endif return true; }
int close_rs485(struct rs485_data_t *rs485_data) { int ret; if ((ret = ftdi_usb_close(rs485_data->ftdi)) < 0) { fprintf(stderr, "unable to close ftdi device: %d (%s)\n", ret, ftdi_get_error_string(rs485_data->ftdi)); ftdi_free(rs485_data->ftdi); return EXIT_FAILURE; } ftdi_free(rs485_data->ftdi); return 0; }
int ftdi_device_close(ftdi_device_t* dev) { error_clear(&dev->error); if (ftdi_usb_purge_buffers(dev->libftdi_context)) error_setf(&dev->error, FTDI_ERROR_PURGE, "%03:%03", dev->bus, dev->address); else if (ftdi_usb_close(dev->libftdi_context)) error_setf(&dev->error, FTDI_ERROR_CLOSE, "%03:%03", dev->bus, dev->address); return error_get(&dev->error); }
int main(int argc, char *argv[] ) { unsigned char fan = 0; char temp = 0; int ret = 0; sem_t * sem_id; if(argc != 2){ printf("usage: ux400opm 1/0\n"); exit(0); } if((ret = sys_init())<0) { printf("LIBFTDI init failed, exit\n"); } temp = cpldver(); if(temp < 0 ) { printf("Read CPLD version failed, exit\n"); exit(1); } printf("before wait\n"); sem_id = sem_open(UX400_SEM_CPLD, O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH, 1); if(sem_id == SEM_FAILED) { perror("UX400 OPM sem_open"); exit(1); } printf("before wait\n"); if(sem_wait(sem_id) < 0) { perror("UX400 OPM sem_wait"); exit(1); } printf("argv[1] = %d\n",atoi(argv[1])); if(atoi(argv[1]) == 1){ printf("argv[1] = 1\n"); opm_pwr(OPM_ON); }else{ printf("argv[1] = else\n"); opm_pwr(OPM_OFF); } if(sem_post(sem_id) < 0) { perror("UX400 OPM sem_post"); } ftdi_usb_close(&ux400_ftdic); ftdi_deinit(&ux400_ftdic); }
QString LibFTDIInterface::readLabel(uchar label, int *ESTA_code) { if (ftdi_usb_open_desc(&m_handle, DMXInterface::FTDIVID, DMXInterface::FTDIPID, name().toLatin1().data(), serial().toLatin1().data()) < 0) return QString(); if (ftdi_usb_reset(&m_handle) < 0) return QString(); if (ftdi_set_baudrate(&m_handle, 250000) < 0) return QString(); if (ftdi_set_line_property(&m_handle, BITS_8, STOP_BIT_2, NONE) < 0) return QString(); if (ftdi_setflowctrl(&m_handle, SIO_DISABLE_FLOW_CTRL) < 0) 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); if (ftdi_write_data(&m_handle, (uchar*) request.data(), request.size()) < 0) { qDebug() << Q_FUNC_INFO << "Cannot write data to device"; return QString(); } uchar *buffer = (uchar*) malloc(sizeof(uchar) * 40); Q_ASSERT(buffer != NULL); QByteArray array; usleep(300000); // give some time to the device to respond int read = ftdi_read_data(&m_handle, buffer, 40); //qDebug() << Q_FUNC_INFO << "Data read: " << read; array = QByteArray::fromRawData((char*) buffer, read); 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 //for (int i = 0; i < array.size(); i++) // qDebug() << "-Data: " << array[i]; ftdi_usb_close(&m_handle); return QString(array); }
/** * Stops the thread loop. * It waits till the command_buffer_ is empty. * It also closes the ftdi_usb object. */ void IncrementParser::Stop() { while(!command_buffer_.empty()) ; if(active_){ active_ = false; pthread_join(thread_, 0); } if(init_done_){ init_done_ = false; ftdi_usb_close(ftdi_); } }
int main (void) { unsigned char buf[128]; unsigned char rbuf[128]; int ret; int i; struct ftdi_context ftdicon; struct ftdi_context *ftdic = &ftdicon; unsigned char d; if (ftdi_init (ftdic) < 0) { fprintf (stderr, "ftdi_init failed\n"); return EXIT_FAILURE; } if ((ret = ftdi_usb_open (ftdic, 0x0403, 0x6010)) < 0) { fprintf (stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string (ftdic)); return EXIT_FAILURE; } fprintf (stdout, "FTDI Opened. Starting SPI init\n"); ft2232_spi_init (ftdic); // Enable accelerometer buf[0] = 0x20; buf[1] = 0x67; ret = ft2232_spi_send_command (ftdic, 2, 0, buf, rbuf); while (1) { buf[0] = ReadAccelerometerRegister (ftdic, ACC_X_AXIS); buf[1] = ReadAccelerometerRegister (ftdic, ACC_Y_AXIS); buf[2] = ReadAccelerometerRegister (ftdic, ACC_Z_AXIS); printf ("X: 0x%02x\tY: 0x%02x\tZ: 0x%02x\n", buf[0], buf[1], buf[2]); usleep (10); } if ((ret = ftdi_usb_close (ftdic)) < 0) { fprintf (stderr, "unable to close ftdi device: %d (%s)\n", ret, ftdi_get_error_string (ftdic)); return EXIT_FAILURE; } ftdi_deinit (ftdic); return EXIT_SUCCESS; }
bool QLCFTDI::close() { if (ftdi_usb_close(&m_handle) < 0) { qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle); return false; } else { return true; } }
int platform_init(void) { int err; if(ftdic) { ftdi_usb_close(ftdic); ftdi_free(ftdic); ftdic = NULL; } if((ftdic = ftdi_new()) == NULL) { fprintf(stderr, "ftdi_new: %s\n", ftdi_get_error_string(ftdic)); abort(); } if((err = ftdi_set_interface(ftdic, INTERFACE_A)) != 0) { fprintf(stderr, "ftdi_set_interface: %d: %s\n", err, ftdi_get_error_string(ftdic)); abort(); } if((err = ftdi_usb_open(ftdic, FT2232_VID, FT2232_PID)) != 0) { fprintf(stderr, "unable to open ftdi device: %d (%s)\n", err, ftdi_get_error_string(ftdic)); abort(); } if((err = ftdi_set_latency_timer(ftdic, 1)) != 0) { fprintf(stderr, "ftdi_set_latency_timer: %d: %s\n", err, ftdi_get_error_string(ftdic)); abort(); } if((err = ftdi_set_baudrate(ftdic, 1000000)) != 0) { fprintf(stderr, "ftdi_set_baudrate: %d: %s\n", err, ftdi_get_error_string(ftdic)); abort(); } if((err = ftdi_usb_purge_buffers(ftdic)) != 0) { fprintf(stderr, "ftdi_set_baudrate: %d: %s\n", err, ftdi_get_error_string(ftdic)); abort(); } if((err = ftdi_write_data_set_chunksize(ftdic, BUF_SIZE)) != 0) { fprintf(stderr, "ftdi_write_data_set_chunksize: %d: %s\n", err, ftdi_get_error_string(ftdic)); abort(); } assert(gdb_if_init() == 0); jtag_scan(NULL); return 0; }
static void ft245r_close(PROGRAMMER * pgm) { if (handle) { // I think the switch to BB mode and back flushes the buffer. ftdi_set_bitmode(handle, 0, BITMODE_SYNCBB); // set Synchronous BitBang, all in puts ftdi_set_bitmode(handle, 0, BITMODE_RESET); // disable Synchronous BitBang ftdi_usb_close(handle); ftdi_deinit (handle); pthread_cancel(readerthread); pthread_join(readerthread, NULL); free(handle); handle = NULL; } }
/*----------------------------------------------------------------------------- * Close / Deinitialize the ICS Interface. * Mainly closes the USB device and deletes the allocated data. * Returns 0 if successful, < 0 otherwise */ int ics_close(ICSData * r) { assert(r); // close usb device if (ftdi_usb_close(&r->ftdic) < 0) ics_ftdi_error(r, "ics_close"); // deinit ftdi_deinit(&r->ftdic); return 0; }
int main(void) { struct ftdi_context ftdic; int f; unsigned char buf[1]; unsigned char bitmask; unsigned char input[10]; if (ftdi_init(&ftdic) < 0) { fprintf(stderr, "ftdi_init failed\n"); return EXIT_FAILURE; } f = ftdi_usb_open(&ftdic, 0x0403, 0x6001); if (f < 0 && f != -5) { fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(&ftdic)); exit(-1); } printf("ftdi open succeeded: %d\n",f); while (1) { // Set bitmask from input fgets(input, sizeof(input) - 1, stdin); if (input[0] == '\n') break; bitmask = strtol(input, NULL, 0); printf("Using bitmask 0x%02x\n", bitmask); f = ftdi_set_bitmode(&ftdic, bitmask, BITMODE_CBUS); if (f < 0) { fprintf(stderr, "set_bitmode failed for 0x%x, error %d (%s)\n", bitmask, f, ftdi_get_error_string(&ftdic)); exit(-1); } // read CBUS f = ftdi_read_pins(&ftdic, &buf[0]); if (f < 0) { fprintf(stderr, "read_pins failed, error %d (%s)\n", f, ftdi_get_error_string(&ftdic)); exit(-1); } printf("Read returned 0x%01x\n", buf[0] & 0x0f); } printf("disabling bitbang mode\n"); ftdi_disable_bitbang(&ftdic); ftdi_usb_close(&ftdic); ftdi_deinit(&ftdic); }