/**
* @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);
}
}
