/** * @param readers Probably should be an empty list. */ list *find_all_readers(struct list *readers) { int rc; struct ftdi_device_list *devlist; struct ftdi_context ftdi; ftdi_init(&ftdi); rc = ftdi_usb_find_all(&ftdi, &devlist, RFID1_VID, RFID1_PID); ftdi_deinit(&ftdi); if(rc < 0) return NULL; struct ftdi_device_list *dp = devlist; while(dp){ struct ftdi_context *c = malloc(sizeof(struct ftdi_context)); if(c == NULL){ // Out of memory !! // TODO: Clean up return NULL; } ftdi_init(c); struct reader *r = reader_create(); reader_init(r, c, dp->dev); list_push(readers, r); dp = dp->next; } ftdi_list_free(&dp); return readers; }
int main(int argc, char *argv[]) { struct ftdi_context ftdic; int portrelay = MOTOR_RELAY; unsigned char relay = 0; /* Initialize context for subsequent function calls */ ftdi_init(&ftdic); /* Open FTDI device based on FT232R vendor & product IDs */ if(ftdi_usb_open(&ftdic, 0x0403, 0x6001) < 0) { puts("Can't open device"); fprintf(stderr, "unable to open ftdi device: (%s)\n", ftdi_get_error_string(&ftdic)); return EXIT_FAILURE; } ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG); /* Reading existing state */ relay = 0; ftdi_read_data(&ftdic, &relay, 1); // printf("Activating relay %d\n", MOTOR_RELAY); relay |= (1 << portrelay); ftdi_write_data(&ftdic, &relay, 1); // printf("Sleeping for %dms\n", SLEEP_TIME); usleep(SLEEP_TIME * 1000); // usleep want microsecs // printf("Dectivating relay %d\n", MOTOR_RELAY); relay &= ~(1 << portrelay); ftdi_write_data(&ftdic, &relay, 1); return 0; }
/* * 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; }
static int ux400_gps_sys_init() { int ret, i; struct ftdi_device_list *devlist, *curdev; char manufacturer[128], description[128], serialno[128]; if (ftdi_init(&ux400_gps_ftdic) < 0) { fprintf(stderr, "ftdi_init failed\n"); return EXIT_FAILURE; } ftdi_set_interface(&ux400_gps_ftdic, UX400_RS232_A); if((ret = ftdi_usb_open_desc(&ux400_gps_ftdic, UX400VENDOR, UX400PRODUCT, UX400DES, UX400_RS232_SN)) < 0) { fprintf(stderr, "ftdi_usb_open_desc failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_gps_ftdic)); return EXIT_FAILURE; } // Set baudrate ret = ftdi_set_baudrate(&ux400_gps_ftdic, GPS_BAUDRATE); if (ret < 0) { fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(&ux400_gps_ftdic)); return EXIT_FAILURE; } return 0; }
/*----------------------------------------------------------------------------- * Iniitialize the ICS interface * Here we mainly setup the FTDI USB-to-serial communication * 115200 baud, 8 bits, even parity, 1 stop bit. * Returns: 0 if successful, < 0 otherwise */ int ics_init(ICSData * r) { assert(r); r->debug = 1; // init usb if (ftdi_init(&r->ftdic) < 0) ics_ftdi_error(r, "ics_init (init usb)"); // select first interface if (ftdi_set_interface(&r->ftdic, INTERFACE_C) < 0) ics_ftdi_error(r, "ics_init (select interface)"); // open usb device if (ftdi_usb_open(&r->ftdic, ICS_USB_VID, ICS_USB_PID) < 0) ics_ftdi_error(r, "ics_init (open usb device)"); // set baud rate if (ftdi_set_baudrate(&r->ftdic, ICS_BAUD) < 0) ics_ftdi_error(r, "ics_init (set baud rate)"); // set line parameters (8E1) if (ftdi_set_line_property(&r->ftdic, BITS_8, STOP_BIT_1, EVEN) < 0) ics_ftdi_error(r, "ics_init (set line params)"); return 0; }
LibFTDIInterface::LibFTDIInterface(const QString& serial, const QString& name, const QString& vendor, quint16 VID, quint16 PID, quint32 id) : DMXInterface(serial, name, vendor, VID, PID , id) { bzero(&m_handle, sizeof(struct ftdi_context)); ftdi_init(&m_handle); }
bool GovernorFtdi::open(OpenMode mode) { int ret; if(ftdi_init(&ftdic) < 0) qDebug("ftdi_init failed"); ret = ftdi_set_interface(&ftdic, INTERFACE_B); if(ret < 0){ qDebug("Error: unable to set interface: %d (%s)", ret, ftdi_get_error_string(&ftdic)); return false; } ret = ftdi_usb_open(&ftdic, 0x0403, 0x6010); if(ret < 0){ qDebug("Error: unable to open ftdi device: %d (%s)", ret, ftdi_get_error_string(&ftdic)); return false; } ret = ftdi_set_baudrate(&ftdic, 115200); if(ret < 0){ qDebug("Error: unable to set baudrate: %d (%s)", ret, ftdi_get_error_string(&ftdic)); return false; } readThread = new GovernorFtdiReadThread(this, &ftdic); connect(readThread, SIGNAL(readyRead()), this, SLOT(on_readThread_readyRead())); readThread->start(); QIODevice::open(mode); return true; }
// // Open the serial port. // Initialise ftdi_context and use it to open the device static dc_status_t serial_ftdi_open (void **userdata, const char* name) { // Allocate memory. ftdi_serial_t *device = (ftdi_serial_t *) malloc (sizeof (ftdi_serial_t)); if (device == NULL) { SYSERROR (context, errno); return DC_STATUS_NOMEMORY; } struct ftdi_context *ftdi_ctx = ftdi_new(); if (ftdi_ctx == NULL) { free(device); SYSERROR (context, errno); return DC_STATUS_NOMEMORY; } // Library context. //device->context = context; // Default to blocking reads. device->timeout = -1; // Default to full-duplex. device->halfduplex = 0; device->baudrate = 0; device->nbits = 0; // Initialize device ftdi context ftdi_init(ftdi_ctx); if (ftdi_set_interface(ftdi_ctx,INTERFACE_ANY)) { free(device); ERROR (context, "%s", ftdi_get_error_string(ftdi_ctx)); return DC_STATUS_IO; } if (serial_ftdi_open_device(ftdi_ctx) < 0) { free(device); ERROR (context, "%s", ftdi_get_error_string(ftdi_ctx)); return DC_STATUS_IO; } if (ftdi_usb_reset(ftdi_ctx)) { free(device); ERROR (context, "%s", ftdi_get_error_string(ftdi_ctx)); return DC_STATUS_IO; } if (ftdi_usb_purge_buffers(ftdi_ctx)) { free(device); ERROR (context, "%s", ftdi_get_error_string(ftdi_ctx)); return DC_STATUS_IO; } device->ftdi_ctx = ftdi_ctx; *userdata = device; return DC_STATUS_SUCCESS; }
int spi_init(void) { LOG(DEBUG, "spi_nrefs=%d, spi_dev_open=%d", spi_nrefs, spi_dev_open); spi_nrefs++; if (spi_nrefs > 1) { LOG(WARN, "Superfluos call to spi_init()"); return 0; } LOG(ALL, "csr-spi-ftdi " VERSION ", git rev " GIT_REVISION "\n"); if (ftdi_init(&ftdic) < 0) { SPI_ERR("FTDI: init failed"); spi_nrefs = 0; return -1; } if (spi_enumerate_ports() < 0) { spi_deinit(); return -1; } return 0; }
static int ublast_ftdi_init(struct ublast_lowlevel *low) { uint8_t latency_timer; struct ftdi_context *ftdic = ublast_getftdic(low); LOG_INFO("usb blaster interface using libftdi"); if (ftdi_init(ftdic) < 0) return ERROR_JTAG_INIT_FAILED; /* context, vendor id, product id */ if (ftdi_usb_open(ftdic, low->ublast_vid, low->ublast_pid) < 0) { LOG_ERROR("unable to open ftdi device: %s", ftdic->error_str); return ERROR_JTAG_INIT_FAILED; } if (ftdi_usb_reset(ftdic) < 0) { LOG_ERROR("unable to reset ftdi device"); return ERROR_JTAG_INIT_FAILED; } if (ftdi_set_latency_timer(ftdic, 2) < 0) { LOG_ERROR("unable to set latency timer"); return ERROR_JTAG_INIT_FAILED; } if (ftdi_get_latency_timer(ftdic, &latency_timer) < 0) { LOG_ERROR("unable to get latency timer"); return ERROR_JTAG_INIT_FAILED; } LOG_DEBUG("current latency timer: %u", latency_timer); ftdi_disable_bitbang(ftdic); return ERROR_OK; }
static int dmx_init(struct ftdi_context* ftdic) { int ret; if (ftdi_init(ftdic) < 0) { fprintf(stderr, "ftdi_init failed\n"); return EXIT_FAILURE; } if ((ret = ftdi_usb_open(ftdic, 0x0403, 0x6001)) < 0) { fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdic)); return EXIT_FAILURE; } if ((ret = ftdi_set_baudrate(ftdic, 250000)) < 0) { fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(ftdic)); return EXIT_FAILURE; } if ((ret = ftdi_set_line_property(ftdic, BITS_8, STOP_BIT_2, NONE)) < 0) { fprintf(stderr, "unable to set line property: %d (%s)\n", ret, ftdi_get_error_string(ftdic)); return EXIT_FAILURE; } if ((ret = ftdi_setflowctrl(ftdic, SIO_DISABLE_FLOW_CTRL)) < 0) { fprintf(stderr, "unable to set flow control: %d (%s)\n", ret, ftdi_get_error_string(ftdic)); return EXIT_FAILURE; } return EXIT_SUCCESS; }
int main() { unsigned char d = 0; unsigned char i; struct ftdi_context ftdic; /* Initialize context for subsequent function calls */ ftdi_init(&ftdic); /* Open FTDI device based on FT232R vendor & product IDs */ if(ftdi_usb_open(&ftdic, 0x0403, 0x6001) < 0) { puts("Can't open device"); fprintf(stderr, "unable to open ftdi device: (%s)\n", ftdi_get_error_string(&ftdic)); return EXIT_FAILURE; } ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG); ftdi_write_data(&ftdic, &d, 1); sleep(1); for(i=0;i<8;i++) { printf("%d\n",d); d |= d<<1; ftdi_write_data(&ftdic, &d, 1); usleep(200 * 1000); } sleep(2); d = 0; ftdi_write_data(&ftdic, &d, 1); return 0; }
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; }
QLCFTDI::QLCFTDI(const QString& serial, const QString& name, quint32 id) : m_serial(serial) , m_name(name) , m_id(id) { bzero(&m_handle, sizeof(struct ftdi_context)); ftdi_init(&m_handle); }
int nifalcon_init(falcon_device* dev) { if((dev->falcon_status_code = ftdi_init(&(dev->falcon))) < 0) return dev->falcon_status_code; dev->is_open = 0; dev->falcon_status_str = ""; dev->is_initialized = 1; return dev->falcon_status_code; }
static int jtagkey_init(unsigned short vid, unsigned short pid) { int ret = 0; unsigned char c; if ((ret = ftdi_init(&ftdic)) != 0) { fprintf(stderr, "unable to initialise libftdi: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return ret; } if ((ret = ftdi_usb_open(&ftdic, vid, pid)) != 0) { fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return ret; } if ((ret = ftdi_usb_reset(&ftdic)) != 0) { fprintf(stderr, "unable reset device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return ret; } if ((ret = ftdi_set_interface(&ftdic, INTERFACE_A)) != 0) { fprintf(stderr, "unable to set interface: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return ret; } if ((ret = ftdi_write_data_set_chunksize(&ftdic, USBBUFSIZE)) != 0) { fprintf(stderr, "unable to set write chunksize: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return ret; } if ((ret = ftdi_read_data_set_chunksize(&ftdic, USBBUFSIZE)) != 0) { fprintf(stderr, "unable to set read chunksize: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return ret; } if ((ret = jtagkey_latency(OTHER_LATENCY)) != 0) return ret; c = 0x00; ftdi_write_data(&ftdic, &c, 1); if ((ret = ftdi_set_bitmode(&ftdic, JTAGKEY_TCK|JTAGKEY_TDI|JTAGKEY_TMS|JTAGKEY_OEn, BITMODE_SYNCBB)) != 0) { fprintf(stderr, "unable to enable bitbang mode: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return ret; } if ((ret = ftdi_set_baudrate(&ftdic, JTAG_SPEED)) != 0) { fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return ret; } if ((ret = ftdi_usb_purge_buffers(&ftdic)) != 0) { fprintf(stderr, "unable to purge buffers: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return ret; } return ret; }
List* List::find_all(int vendor, int product) { struct ftdi_device_list* dlist = 0; struct ftdi_context ftdi; ftdi_init(&ftdi); ftdi_usb_find_all(&ftdi, &dlist, vendor, product); ftdi_deinit(&ftdi); return new List(dlist); }
EnttecDMXUSBOpen::EnttecDMXUSBOpen(QObject* parent, const QString& name, const QString& serial) : QThread(parent) , m_name(name) , m_serial(serial) , m_running(false) , m_universe(QByteArray(513, 0)) { ftdi_init(&m_context); }
QLCFTDI::QLCFTDI(const QString& serial, const QString& name, const QString& vendor, quint32 id) : m_serial(serial) , m_name(name) , m_vendor(vendor) , m_id(id) , m_refCount(1) , m_openCount(0) { bzero(&m_handle, sizeof(struct ftdi_context)); ftdi_init(&m_handle); }
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; }
struct ftdi_context * bub_init(unsigned int baud_rate, unsigned char latency, unsigned int tx_buf_size, unsigned int rx_buf_size) { int ret = 0; struct ftdi_context *ftdic; ftdic = malloc(sizeof(struct ftdi_context)); if(ftdic == NULL) { perror("malloc"); return(NULL); } ret = ftdi_init(ftdic); if (ret < 0) { fprintf(stderr, "ftdi_init failed: %d.\n", ret); return(NULL); } ftdi_set_interface(ftdic, INTERFACE_ANY); ret = ftdi_usb_open(ftdic, 0x0403, 0x6001); // FIXME make nice defines if(ret < 0) { fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdic)); return(NULL); } if(ftdi_usb_reset(ftdic) != 0) fprintf(stderr, "WARN: ftdi_usb_reset failed!\n"); ftdi_disable_bitbang(ftdic); if (ftdi_set_baudrate(ftdic, baud_rate) < 0) { fprintf(stderr, "Unable to set baudrate: (%s)\n", ftdi_get_error_string(ftdic)); return(NULL); } ftdi_set_latency_timer(ftdic, latency); if(tx_buf_size > 0) ftdi_write_data_set_chunksize(ftdic, tx_buf_size); if(rx_buf_size > 0) ftdi_read_data_set_chunksize(ftdic, rx_buf_size); return(ftdic); }
int ftdi_context_refresh(ftdi_context_t* context) { struct usb_bus* libusb_bus; struct usb_device* libusb_device; struct ftdi_context* libftdi_context; int i = 0; error_clear(&context->error); if (context->num_references) { if (context->num_devices) { for (i = 0; i < context->num_devices; ++i) ftdi_device_destroy(&context->devices[i]); free(context->devices); context->devices = 0; context->num_devices = 0; } usb_init(); if ((usb_find_busses() > 0) && (usb_find_devices() > 0)) { for (libusb_bus = usb_get_busses(); libusb_bus; libusb_bus = libusb_bus->next) for (libusb_device = libusb_bus->devices; libusb_device; libusb_device = libusb_device->next) if (libusb_device->descriptor.idVendor == FTDI_VENDOR_ID) context->num_devices++; } if (context->num_devices) { context->devices = malloc(context->num_devices*sizeof(ftdi_device_t)); i = 0; for (libusb_bus = usb_get_busses(); libusb_bus; libusb_bus = libusb_bus->next) for (libusb_device = libusb_bus->devices; libusb_device; libusb_device = libusb_device->next) if (libusb_device->descriptor.idVendor == FTDI_VENDOR_ID) { libftdi_context = ftdi_new(); ftdi_init(libftdi_context); ftdi_device_init(&context->devices[i], libftdi_context, libusb_bus, libusb_device); i++; } } } else error_set(&context->error, FTDI_ERROR_INVALID_CONTEXT); return error_get(&context->error); }
int main(int argc, char *argv[]) { int ret; struct ftdi_context ftdic; struct adapter *adap; struct adapter_ops *ops; ops = &v2_ops; if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) print_usage(argv[0]); if (ftdi_init(&ftdic) < 0) { fprintf(stderr, "ftdi_init failed\n"); return EXIT_FAILURE; } ftdi_set_interface(&ftdic, ops->interface); if (argc > 1 && strchr(argv[1],':')) { ret = ftdi_usb_open_string(&ftdic, argv[1]); argv++; argc--; } else ret = ftdi_usb_open_desc(&ftdic, 0x0403, 0x6010, ops->desc, NULL); if (ret < 0) { fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return EXIT_FAILURE; } adap = adapter_attach(&ftdic, ops, 0); if (!adap) { perror("attach"); return EXIT_FAILURE; } if (argc < 2) { short shunt_v; int shunt_v_sh; unsigned int bus_v; double shunt; double bus; double r = 0.050; double current; double power; unsigned char cmdbuf[] = {1, 2}; unsigned char msgbuf[2][2]; struct i2c_msg msgs[] = { { .addr = ADDR, .len = 1, .buf = cmdbuf }, { .addr = ADDR, .flags = I2C_M_RD, .len = 2, .buf = msgbuf[0] },
bool IntanThread::initializeUSB(bool verbose) { int return_value; // Step 1: initialise the ftdi_context: if (ftdi_init(&ftdic) < 0) // -1 = couldn't allocate read buffer { // -2 = couldn't allocate struct buffer if (verbose) fprintf(stderr, "ftdi_init failed\n"); return false; } else { if (verbose) std::cout << "FTDI context initialized." << std::endl; } // Step 2: open USB device // -3 = device not found // -8 = wrong permissions if ((return_value = ftdi_usb_open(&ftdic, vendorID, productID)) < 0) { if (verbose) fprintf(stderr, "unable to open FTDI device: %d (%s)\n", return_value, ftdi_get_error_string(&ftdic)); return false; } else { std::cout << "USB connection opened." << std::endl; } // Step 3: set the baud rate if ((return_value = ftdi_set_baudrate(&ftdic, baudrate)) < 0) { if (verbose) fprintf(stderr, "unable to set baud rate: %d (%s)\n", return_value, ftdi_get_error_string(&ftdic)); return false; } else { std::cout << "Baud rate set to 115200" << std::endl; } return true; }
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); }
bool FTDIDevice::connect (int baudrate) throw () { #ifdef FOUND_ftdi int ret, i; disconnect(); ftdi_init (&_ftdic); while ((ret = ftdi_usb_open(&_ftdic, 0x0403, 0x6001)) < 0) FTDERROR("unable to open ftdi device: " << ret << " (" << ftdi_get_error_string(&_ftdic) << ")"); for (i=0, ret=-1; i<10 && ret!=0; i++) ret = ftdi_usb_reset(&_ftdic); if (ret != 0) { FTDERROR("unable to reset ftdi device."); return false; } for (i=0, ret=-1; i<10 && ret!=0; i++) ret = ftdi_set_baudrate(&_ftdic, baudrate); if (ret != 0) { FTDERROR("unable to set baud rate."); return false; } if (_latency > 0) for (i=0, ret=-1; i<10 && ret!=0; i++) ret = ftdi_set_latency_timer(&_ftdic, _latency); if (ret != 0) { FTDERROR("unable to set latency timer."); return false; } for (i=0, ret=-1; i<10 && ret!=0; i++) ret = ftdi_usb_purge_buffers(&_ftdic); if (ret != 0) { FTDERROR("unable to purge buffers."); return false; } _initialized = true; FTDLOG("Connection successful."); return true; #else _initialized = false; FTDERROR("cannot connect FTDI device: compiled without required libraries"); return false; #endif }
bool FalconCommLibFTDI::initLibFTDI() { #if defined(LIBUSB_DEBUG) //Spam libusb messages usb_set_debug(10); #endif if((m_deviceErrorCode = ftdi_init((m_falconDevice))) < 0) { m_errorCode = FALCON_COMM_DEVICE_ERROR; return false; } m_isInitialized = true; return true; }
int GetFTDIDevicePortNumUSingLibFTDI(UInt32 locationIDFromInterface) { int ret, i; struct ftdi_context ftdic; struct ftdi_device_list *devlist, *curdev; char manufacturer[128], description[128]; if (ftdi_init(&ftdic) < 0) { fprintf(stderr, "ftdi_init failed\n"); return -1; } if ((ret = ftdi_usb_find_all(&ftdic, &devlist, 0x0403, 0x6001)) < 0) { fprintf(stderr, "ftdi_usb_find_all failed: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return -1; } printf("Number of FTDI devices found: %d\n", ret); i = 0; for (curdev = devlist; curdev != NULL; i++) { //printf("Checking device: %d\n", i); if ((ret = ftdi_usb_get_strings(&ftdic, curdev->dev, manufacturer, 128, description, 128, NULL, 0)) < 0) { fprintf(stderr, "ftdi_usb_get_strings failed: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return -1; } uint32_t *locationId = (uint32_t *)malloc(sizeof(uint32_t)); xlibusb_get_device_location_id((struct libusb_device *)curdev->dev->dev,locationId); printf("Manufacturer: %s, Description: %s\n\n", manufacturer, description); if ((*locationId) == locationIDFromInterface) { free(locationId); return i; } free(locationId); //printf("0x%x deviceDesc[%d] %s",(unsigned int)&(deviceDesc[i]),i,deviceDesc[i]); curdev = curdev->next; } ftdi_list_free(&devlist); ftdi_deinit(&ftdic); return -1; }
void init_hw () { ftdi_ok = FALSE; if (ftdi_init (&ctx) >= 0) { int f = ftdi_usb_open (&ctx, 0x0403, 0x6001); if (f >= 0 || f == -5) { purple_debug_info ("hwnotify", "INIT OK\n"); ftdi_set_bitmode (&ctx, 0xFF, BITMODE_BITBANG); ftdi_ok = TRUE; } } }
void ftdi_bootup() { if(ftdi_init(&ftdi)!=0) printf("ftdi - could not be opened.\nr"); else printf("booting up.\n"); if(ftdi_usb_open_desc(&ftdi,0x0403, 0x6001,NULL/*description*/,usb_serial)!=0) printf("ftdi - error.\n"); else { printf("ftdi opened.\n"); ftdi_set_baudrate(&ftdi,115200); } }