/**
* Will initialize the ftdi connection.
* @return 0 on success.
*/
int IncrementParser::InitRS232() {
int ret = 100;
if ((ftdi_ = ftdi_new()) == 0){
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
if ((ret = ftdi_usb_open(ftdi_, 0x0403, 0x6001)) < 0){
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi_));
ftdi_free(ftdi_);
return EXIT_FAILURE;
}
// Read out FTDIChip-ID of R type chips
if (ftdi_->type == TYPE_R){
unsigned int chipid;
printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(ftdi_, &chipid));
printf("FTDI chipid: %X\n", chipid);
}
ftdi_set_baudrate(ftdi_, baudrate_);
printf("Baudrate set to: %d\n", baudrate_);
init_done_ = true;
return EXIT_SUCCESS;
}
//
// 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 init_rs485(struct rs485_data_t *rs485_data) {
int ret;
rs485_data->ftdi = ftdi_new();
if (!rs485_data->ftdi) {
fprintf(stderr, "ftdi_new failed\n");
return -1;
}
/* check for FT232RL device */
if ((ret = ftdi_usb_open(rs485_data->ftdi, 0x0403, 0x6001)) < 0) {
fprintf(stderr, "unable to open FTDI device: %d (%s)\n", ret, ftdi_get_error_string(rs485_data->ftdi));
ftdi_free(rs485_data->ftdi);
return EXIT_FAILURE;
}
if ((ret = ftdi_set_baudrate(rs485_data->ftdi, rs485_data->speed)) < 0) {
fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(rs485_data->ftdi));
ftdi_free(rs485_data->ftdi);
return EXIT_FAILURE;
}
if ((ret = ftdi_setflowctrl(rs485_data->ftdi, SIO_DISABLE_FLOW_CTRL)) < 0) {
fprintf(stderr, "unable to set flow control: %d (%s)\n", ret, ftdi_get_error_string(rs485_data->ftdi));
return EXIT_FAILURE;
}
return 0;
}
int main(int argc, char *argv[])
{
int num_devs;
struct ftdi_context *ctx;
struct ftdi_device_list *devs = NULL;
(void)argc;
(void)argv;
ctx = ftdi_new();
if (!ctx) {
printf("Initialization error.\n");
return 1;
}
num_devs = ftdi_usb_find_all(ctx, &devs, 0, 0);
if (num_devs < 0) {
printf("Device list error: %s.\n", ftdi_get_error_string(ctx));
ftdi_free(ctx);
return 2;
}
printf("Found %d FTDI devices.\n", (int)num_devs);
ftdi_list_free(&devs);
ftdi_free(ctx);
return 0;
}
/*
* Return a list of devices found by libftdi together with a number of fields
* describing the corresponding USB device.
* The list is internally cached. To free it, call freeDeviceList().
*
* Returns: a vector pointer containing 0 or more devices, or NULL if an error
* occured while retrieving the list. When NULL is returned, this is guaranteed
* to be an ftdi error.
*/
const FtdiDevice::vec_deviceInfo* FtdiDevice::getDeviceList( ftdi_context* c )
{
ftdi_context* context = c ? c : ftdi_new();
if ( context == 0 ) return 0;
if ( s_deviceList != 0 ) freeDeviceList();
int r = ftdi_usb_find_all( context, &s_ftdiDeviceList, USB_VENDOR_ID, USB_PRODUCT_ID );
s_deviceList = new vec_deviceInfo();
if ( r >= 0 ) {
struct ftdi_device_list* openDev = s_ftdiDeviceList;
while ( openDev ) {
struct deviceInfo info;
info.ftdiDevice = openDev->dev;
info.usbInfo = fetchUsbInformation( context, info.ftdiDevice );
s_deviceList->push_back( info );
openDev = openDev->next;
}
}
//Only free the context if it has been allocated locally.
if ( c == 0 ) ftdi_free( context );
return s_deviceList;
}
void spi_init(void) {
int ret;
ftdi = ftdi_new();
if (!ftdi) {
fatal_error("ftdi_new failed!\n");
}
ret = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (ret < 0 && ret != -5) {
ftdi_free(ftdi);
fatal_error("unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
}
ret = ftdi_set_bitmode(ftdi, PINS_OUT, BITMODE_SYNCBB);
if (ret != 0) {
ftdi_free(ftdi);
fatal_error("unable to set bitmode: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
}
ret = ftdi_set_baudrate(ftdi, 57600);
if (ret != 0) {
ftdi_disable_bitbang(ftdi);
ftdi_free(ftdi);
fatal_error("unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
}
}
cell ft_open_serial (cell devidx, cell pid)
{
ft_handle fh = ftdi_new();
ft_errno = ftdi_usb_open_desc_index(fh, 0x0403, pid, NULL, NULL, devidx);
if (ft_errno) {
return (cell)NULL;
}
ftdi_set_baudrate(fh, 115200);
ftdi_set_line_property(fh, BITS_8, STOP_BIT_1, NONE);
ftdi_setflowctrl(fh, SIO_DISABLE_FLOW_CTRL);
ftdi_set_latency_timer(fh, 1);
com_ops_t *ops = malloc(sizeof(com_ops_t));
ops->handle = (cell)fh;
ops->close = ft_close;
ops->get_modem_control = ft_get_modem_control;
ops->set_modem_control = ft_set_modem_control;
ops->set_baud = ft_set_baud;
ops->set_parity = ft_set_parity;
ops->write = ft_write;
ops->timed_read = ft_timed_read;
return (cell)ops;
}
void OBDDevice::setupFTDI() {
if ( !(ftdi = ftdi_new()) ) {
qDebug() << __FILE__ << __LINE__ << ": Failed to create ftdi context";
return;
}
if ( ftdi_set_interface( ftdi, INTERFACE_ANY ) < 0 ) {
qDebug() << __FILE__ << __LINE__ << ": Unable to set interface: " << ftdi_get_error_string( ftdi );
return;
}
if ( ftdi_usb_open_desc( ftdi, VID, PID, DESCRIPTION, NULL ) < 0 ) {
qDebug() << __FILE__ << __LINE__ << ": Unable to open ftdi device: " << ftdi_get_error_string( ftdi );
return;
}
if ( ftdi_set_baudrate( ftdi, BAUDRATE ) < 0 ) {
qDebug() << __FILE__ << __LINE__ << ": Unable to set baudrate: " << ftdi_get_error_string( ftdi );
return;
}
if ( ftdi_set_line_property( ftdi, BITS_8, STOP_BIT_1, NONE ) < 0 ) {
qDebug() << __FILE__ << __LINE__ << ": Unable to set line parameters: " << ftdi_get_error_string( ftdi );
return;
}
ftdi_usb_purge_buffers(ftdi);
}
FtdiWrapper::FtdiWrapper(unsigned int vid, unsigned int pid, string description,
string serialNum)
{
try
{
//construct connection context
ftdiContext = ftdi_new();
if(ftdiContext == NULL)
throw runtime_error("unable to initialize ftdi driver");
//open connection
const char *desc = ( description.empty() ? NULL : description.c_str() );
const char *serial = ( serialNum.empty() ? NULL : serialNum.c_str() );
int rtn = ftdi_usb_open_desc(ftdiContext, vid, pid, desc, serial);
if(rtn < 0)
{
stringstream msg;
msg << "unable to open ftdi connection: ";
msg << ftdi_get_error_string(ftdiContext);
// msg << " (Do you have sufficient privileges to access the usb bus? Is the device connected?)";
throw runtime_error( msg.str() );
}
}
catch(...)
{
ftdi_free(ftdiContext);
throw;
}
}
static struct ftdi_context *open_ftdi_device(int vid, int pid,
int interface, char *serial)
{
struct ftdi_context *ftdi;
int ret;
ftdi = ftdi_new();
if (!ftdi) {
fprintf(stderr, "Cannot allocate context memory\n");
return NULL;
}
ret = ftdi_set_interface(ftdi, interface);
if (ret < 0) {
fprintf(stderr, "cannot set ftdi interface %d: %s(%d)\n",
interface, ftdi_get_error_string(ftdi), ret);
goto open_failed;
}
ret = ftdi_usb_open_desc(ftdi, vid, pid, NULL, serial);
if (ret < 0) {
fprintf(stderr, "unable to open ftdi device: %s(%d)\n",
ftdi_get_error_string(ftdi), ret);
goto open_failed;
}
return ftdi;
open_failed:
ftdi_free(ftdi);
return NULL;
}
static int dev_open(struct sr_dev_inst *sdi)
{
struct dev_context *devc;
int ret;
if (!(devc = sdi->priv))
return SR_ERR_BUG;
/* Allocate memory for the FTDI context and initialize it. */
if (!(devc->ftdic = ftdi_new())) {
sr_err("Failed to initialize libftdi.");
return SR_ERR;
}
sr_dbg("Opening %s device (%04x:%04x).", devc->prof->modelname,
devc->usb_vid, devc->usb_pid);
/* Open the device. */
if ((ret = ftdi_usb_open_desc(devc->ftdic, devc->usb_vid,
devc->usb_pid, devc->prof->iproduct, NULL)) < 0) {
sr_err("Failed to open FTDI device (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_ftdi_free;
}
sr_dbg("Device opened successfully.");
/* Purge RX/TX buffers in the FTDI chip. */
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));
goto err_ftdi_free;
}
sr_dbg("FTDI buffers purged successfully.");
/* Enable flow control in the FTDI chip. */
if ((ret = ftdi_setflowctrl(devc->ftdic, SIO_RTS_CTS_HS)) < 0) {
sr_err("Failed to enable FTDI flow control (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_ftdi_free;
}
sr_dbg("FTDI flow control enabled successfully.");
/* Wait 100ms. */
g_usleep(100 * 1000);
sdi->status = SR_ST_ACTIVE;
if (ret == SR_OK)
return SR_OK;
err_ftdi_free:
ftdi_free(devc->ftdic); /* Close device (if open), free FTDI context. */
devc->ftdic = NULL;
return ret;
}
void list_devices() {
struct ftdi_context *ftdi;
struct ftdi_device_list *dev_list;
struct ftdi_device_list *dev_current;
int num_devices;
ftdi = ftdi_new();
if (!ftdi) {
fprintf(stderr, "failed to initialize ftdi context\n");
exit(1);
}
num_devices = ftdi_usb_find_all(ftdi, &dev_list, VID, PID);
if (num_devices < 0) {
fprintf(stderr, "ftdi error: %s\n",
ftdi_get_error_string(ftdi));
goto error;
}
if (!num_devices) {
printf("unable to find saturn device!\n");
goto done;
}
dev_current = dev_list;
num_devices = 0;
while (dev_current) {
char manufacturer[255];
char description[255];
char serial[255];
if (ftdi_usb_get_strings(ftdi, dev_current->dev,
manufacturer, 255,
description, 255,
serial, 255) < 0) {
fprintf(stderr, "ftdi error: %s\n",
ftdi_get_error_string(ftdi));
goto done;
}
if (strcmp(DESCRIPTION, description) == 0)
printf("%d: %s (%s, %s)\n", num_devices++, description,
manufacturer, serial);
dev_current = dev_current->next;
}
if (!num_devices)
printf("unable to find saturn device!\n");
done:
ftdi_list_free(&dev_list);
error:
ftdi_free(ftdi);
}
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;
}
int main(void)
{
struct ftdi_context *ftdi;
int retval = EXIT_SUCCESS;
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
return retval;
}
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;
int i;
struct ftdi_context *ftdi;
unsigned int chipid;
unsigned char buf[256];
track *tracks;
int ntracks;
ftdi = ftdi_new();
ret = ftdi_usb_open(ftdi, 0x0403, 0xB70A);
if (ret < -1) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n",
ret, ftdi_get_error_string(ftdi));
return ret;
}
printf("type=%d\n", ftdi->type);
ftdi_read_chipid(ftdi, &chipid);
printf("chipid=%x\n", chipid);
setup(ftdi);
ftdi_setrts(ftdi, 1);
while((ret = ftdi_read_data(ftdi, buf, 256)) > 0) {
for(i = 0; i < ret; ++i)
printf("%02X ", buf[i]);
}
ftdi_setrts(ftdi, 0);
read_version(ftdi);
read_product(ftdi);
read_list(ftdi, &tracks, &ntracks);
if (argc > 1) {
i = atoi(argv[1]);
printf("tracks[%d].no=%d\n", i, tracks[i].no);
read_track_points(ftdi, &tracks[i], i);
}
free(tracks);
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
return 0;
}
int main(int argc, char **argv)
{
struct ftdi_context *ftdi;
int f;
unsigned char buf[1];
int retval = 0;
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
// fprintf(stderr, "ftdi_new result = %d\n", ftdi);
f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
// fprintf(stderr, "ftdi_usb_open result = %d\n", f);
if (f < 0 && f != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
retval = 1;
goto done;
}
// printf("ftdi open succeeded: %d\n",f);
// printf("enabling bitbang mode\n");
ftdi_set_bitmode(ftdi, 0x02, BITMODE_BITBANG);
// usleep(3 * 1000000);
buf[0] = 0xff;
// printf("turning everything on\n");
f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
{
fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(ftdi));
}
// ftdi_disable_bitbang(ftdi);
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
done:
return retval;
}
//Constructor
Dionysus::Dionysus(bool debug){
printf ("%s(): Entered\n", __func__);
//Open up Dionysus
this->debug = debug;
this->usb_is_open = false;
this->comm_mode = false;
this->usb_constructor();
if (this->debug) printf ("Dionysus: Debug Enabled\n");
//Open up a context and initialize it
this->ftdi = ftdi_new();
int retval = 0;
retval = ftdi_init(this->ftdi);
if (retval != 0){
printf ("Error initializing FTDI Context\n");
}
}
int main(void)
{
int ret;
struct ftdi_context *ftdi;
struct ftdi_version_info version;
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
version = ftdi_get_library_version();
printf("Initialized libftdi %s (major: %d, minor: %d, micro: %d, snapshot ver: %s)\n",
version.version_str, version.major, version.minor, version.micro,
version.snapshot_str);
// // own stuff
// struct ftdi_device_list *devList;
// if ((ret = ftdi_usb_find_all(ftdi,devList, 0, 0)) < 0)
// {
// fprintf(stderr, "unable to find devices: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
// ftdi_free(ftdi);
// return EXIT_FAILURE;
// }
if ((ret = ftdi_usb_open(ftdi, 0x0403, 0x6014)) < 0)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return EXIT_FAILURE;
}
// Read out FTDIChip-ID of R type chips
if (ftdi->type == TYPE_232H)
{
unsigned int chipid;
printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(ftdi, &chipid));
printf("FTDI chipid: %X\n", chipid);
}
if ((ret = ftdi_usb_close(ftdi)) < 0)
{
fprintf(stderr, "unable to close ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return EXIT_FAILURE;
}
ftdi_free(ftdi);
return EXIT_SUCCESS;
}
static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
int ret;
unsigned int i;
GSList *devices;
struct ftdi_context *ftdic;
(void)di;
(void)options;
devices = NULL;
/* Allocate memory for the FTDI context and initialize it. */
if (!(ftdic = ftdi_new())) {
sr_err("Failed to initialize libftdi.");
return NULL;
}
/* Check for LA8 and/or LA16 devices with various VID/PIDs. */
for (i = 0; i < ARRAY_SIZE(vid_pid); i++) {
ret = ftdi_usb_open_desc(ftdic, vid_pid[i].vid,
vid_pid[i].pid, vid_pid[i].iproduct, NULL);
/* Show errors other than "device not found". */
if (ret < 0 && ret != -3)
sr_dbg("Error finding/opening device (%d): %s.",
ret, ftdi_get_error_string(ftdic));
if (ret < 0)
continue; /* No device found, or not usable. */
sr_dbg("Found %s device (%04x:%04x).",
vid_pid[i].iproduct, vid_pid[i].vid, vid_pid[i].pid);
if ((ret = add_device(i, vid_pid[i].model, &devices)) < 0)
sr_dbg("Failed to add device: %d.", ret);
if ((ret = ftdi_usb_close(ftdic)) < 0)
sr_dbg("Failed to close FTDI device (%d): %s.",
ret, ftdi_get_error_string(ftdic));
}
/* Close USB device, deinitialize and free the FTDI context. */
ftdi_free(ftdic);
ftdic = NULL;
return devices;
}
void ftdi_reader_create() {
if ((ftdi_c = ftdi_new()) == 0)
{
Throw(FTDI_NEW_FAILED);
}
if (ftdi_usb_open(ftdi_c, FTDI_VID, FTDI_PID)!=0) {
ftdi_free(ftdi_c);
Throw(FTDI_USB_OPEN_FAILED);
}
if (ftdi_set_baudrate(ftdi_c, 3000000)!=0) {
ftdi_usb_close(ftdi_c);
ftdi_free(ftdi_c);
Throw(FTDI_SET_BAUDRATE_FAILED);
}
}
int main(int argc, char **argv)
{
struct ftdi_context *ftdi;
int i, t;
unsigned char data;
int delay = 100000; /* 100 thousand microseconds: 1 tenth of a second */
while ((t = getopt (argc, argv, "d:")) != -1)
{
switch (t)
{
case 'd':
delay = atoi (optarg);
break;
}
}
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_bew failed\n");
return EXIT_FAILURE;
}
if (ftdi_usb_open(ftdi, 0x0403, 0x6010) < 0)
ftdi_fatal (ftdi, "Can't open ftdi device");
if (ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG) < 0)
ftdi_fatal (ftdi, "Can't enable bitbang");
for (i=optind; i < argc ; i++)
{
sscanf (argv[i], "%x", &t);
data = t;
if (ftdi_write_data(ftdi, &data, 1) < 0)
{
fprintf(stderr,"write failed for 0x%x: %s\n",
data, ftdi_get_error_string(ftdi));
}
usleep(delay);
}
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
exit (0);
}
void relay_setup (void) {
int f;
if ((ftdi = ftdi_new()) == 0) {
printf("ftdi_new failed\nFatal error, exiting\n");
exit (1);
}
f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (f < 0 && f != -5) {
printf("Unable to open ftdi device %s\nFatal error, exiting\n", ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
exit (1);
}
ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG);
return;
}
int init()
{
int f;
if ((ftdi = ftdi_new()) == 0) {
fprintf(stderr, "ftdi_new failed\n");
return -1;
}
f = ftdi_usb_open(ftdi, 0x0403, 0x6010);
if (f < 0 && f != -5) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
ftdi = NULL;
return -1;
}
f = ftdi_set_bitmode(ftdi, 0xff, BITMODE_MPSSE);
if(f != 0) {
fprintf(stderr, "unable to set bit mode: %d (%s)\n", f, ftdi_get_error_string(ftdi));
release();
return -1;
}
uint8_t p[] = { 0x80, 0, 3 };
f = ftdi_write_data(ftdi, p, 3);
if(f != 3) {
fprintf(stderr, "unable to write command to ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
release();
return -1;
}
//Set TCK/SK Divisor 0x86, 0xValueL, 0xValueH
uint8_t p1[] = { 0x86, 0, 1 }; //250KHz
// uint8_t p1[] = { 0x86, 0, 10 }; //25KHz
f = ftdi_write_data(ftdi, p1, 3);
if(f != 3) {
fprintf(stderr, "unable to write command2 to ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
release();
return -1;
}
return 0;
}
int main(int argc, char **argv)
{
struct ftdi_context *ftdi;
int f = 0;
int vid = 0x403; /* USB vendor ID -- use 'lsusb' to see */
int pid = 0x6001; /* USB product ID */
tpl_node *tn;
tn = tpl_map("cccc",&R,&G,&B,&D);
if ((ftdi = ftdi_new()) == 0) {
fprintf(stderr, "ftdi_new failed\n");
return -1;
}
ftdi_set_interface(ftdi, INTERFACE_ANY);
f = ftdi_usb_open(ftdi, vid, pid);
if (f < 0)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
fprintf(stderr, "you may need to run as root\n");
return -1;
}
f = ftdi_write_data(ftdi, enttec_msg, sizeof(enttec_msg));
while(tpl_load(tn, TPL_FD, 0) == 0) {
tpl_unpack(tn,0);
fprintf(stderr,"writing %d %d %d %d\n", R,G,B,D);
enttec_msg[6] = R;
enttec_msg[7] = G;
enttec_msg[8] = B;
enttec_msg[9] = 0;
enttec_msg[10] = D;
ftdi_write_data(ftdi, enttec_msg, sizeof(enttec_msg));
}
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
tpl_free(tn);
return 0;
}
CKMotionIO::CKMotionIO()
{
ConsoleHandler=NULL;
Mutex = new CMutex(FALSE,"KMotionIO",0);
m_Connected=false;
SendAbortOnConnect=true;
FailMessageAlreadyShown=false;
Token=0;
NonRespondingCount=0;
m_FirmwareVersion=2;
USB_Loc_ID=-1;
BoardIDAssigned=false;
if ((ftdi = ftdi_new()) == 0)
{
log_info("ftdi_new failed.");
exit(EXIT_FAILURE);
}
}
/* prepare the FTDI USB device */
int do_init(struct ftdi2s88_t *fs88) {
fs88->ftdic = ftdi_new();
if (!fs88->ftdic) {
fprintf(stderr, "ftdi_new failed\n");
return -1;
}
if (ftdi_usb_open_desc(fs88->ftdic, 0x0403, 0x6001, NULL, NULL) < 0) {
/* if (ftdi_usb_open_desc(ftdic, 0x0403, 0x6015, NULL, NULL) < 0) { */
fprintf(stderr, "ftdi_usb_open_desc failed: %s\n", ftdi_get_error_string(fs88->ftdic));
return -1;
}
if (ftdi_set_bitmode(fs88->ftdic, BITBANG_MASK, BITMODE_SYNCBB) < 0) {
fprintf(stderr, "ftdi_set_bitmode failed: %s\n", ftdi_get_error_string(fs88->ftdic));
return -1;
}
if (ftdi_set_baudrate(fs88->ftdic, fs88->baudrate) < 0) {
fprintf(stderr, "ftdi_set_baudrate failed: %s\n", ftdi_get_error_string(fs88->ftdic));
return -1;
}
if (ftdi_usb_purge_tx_buffer(fs88->ftdic)) {
fprintf(stderr, "tx buffer flushing failed: %s\n", ftdi_get_error_string(fs88->ftdic));
return -1;
}
if (ftdi_usb_purge_rx_buffer(fs88->ftdic)) {
fprintf(stderr, "rx buffer flushing failed: %s\n", ftdi_get_error_string(fs88->ftdic));
return -1;
}
return 0;
}
//
// Open the serial port.
// Initialise ftdi_context and use it to open the device
static dc_status_t serial_ftdi_open (void **io, dc_context_t *context)
{
INFO(0, "serial_ftdi_open called");
// Allocate memory.
ftdi_serial_t *device = (ftdi_serial_t *) malloc (sizeof (ftdi_serial_t));
if (device == NULL) {
INFO(0, "couldn't allocate memory");
SYSERROR (context, errno);
return DC_STATUS_NOMEMORY;
}
INFO(0, "setting up ftdi_ctx");
struct ftdi_context *ftdi_ctx = ftdi_new();
if (ftdi_ctx == NULL) {
INFO(0, "failed ftdi_new()");
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->baudrate = 0;
device->nbits = 0;
device->databits = 0;
device->stopbits = 0;
device->parity = 0;
// Initialize device ftdi context
INFO(0, "initialize ftdi_ctx");
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;
}
INFO(0, "call serial_ftdi_open_device");
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;
*io = device;
return DC_STATUS_SUCCESS;
}
int main(void)
{
//set interrupt handler for CTRL+C
signal(SIGINT,sigintHandler);
int ret;
struct ftdi_context *ftdi;
struct ftdi_version_info version;
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
version = ftdi_get_library_version();
printf("Initialized libftdi %s (major: %d, minor: %d, micro: %d, snapshot ver: %s)\n",
version.version_str, version.major, version.minor, version.micro,
version.snapshot_str);
if ((ret = ftdi_usb_open(ftdi, 0x0403, 0x6014)) < 0)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return EXIT_FAILURE;
}
// Read out FTDIChip-ID of R type chips
if (ftdi->type == TYPE_232H)
{
unsigned int chipid;
printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(ftdi, &chipid));
printf("FTDI chipid: %X\n", chipid);
}
printf("Resetting...");
if ((ret = ftdi_set_bitmode(ftdi, 0x00, BITMODE_RESET)) != 0)
{
fprintf(stderr, "unable to reset: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
return EXIT_FAILURE;
}
printf(" success!\n");
printf("Setting mode 245...");
if ((ret = ftdi_set_bitmode(ftdi, 0x00, BITMODE_SYNCFF)) != 0)
{
fprintf(stderr, "unable to set to mode 245: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
return EXIT_FAILURE;
}
printf(" success!\n");
//ACBUS5 already outputs the 30MHz clock
//Is this the bit that caused the error? Try commenting out for now and see what it does.
/*
printf("Setting ACBUS[8] to 30 MHz...");
if ((ret = ftdi_set_eeprom_value(ftdi,CBUS_FUNCTION_8,CBUSH_CLK30)) != 0)
{
fprintf(stderr, " unable to set: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
return EXIT_FAILURE;
}
else
{
printf(" success!\n");
}
//lets make sure that the eeprom value was set....
int val;
ret = ftdi_get_eeprom_value(ftdi,CBUS_FUNCTION_8,&val);
printf("ret: %d val: %d\n",ret,val);
printf("does val match %d?\n",CBUSH_CLK30);
*/
unsigned char buf[1024];
int its = 10000;
return;
while(quit == 0)
{
//ret = ftdi_read_data(&ftdic,&buf,1);
if ((ret = ftdi_read_data(ftdi,buf,3)) < 0)
{
fprintf(stderr, "unable to read ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
//return EXIT_FAILURE;
}
else
{
printf("Read in %x %x %x\n", buf[0],buf[1],buf[2]);
}
}
if ((ret = ftdi_usb_close(ftdi)) < 0)
{
fprintf(stderr, "unable to close ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return EXIT_FAILURE;
}
ftdi_free(ftdi);
return EXIT_SUCCESS;
}
/*
* Open an FTDI device. The device is selected with regard to the given restrictions;
* any of those may be NULL and index is counted in the subset selected by the
* description and/or serial if given.
*
* Returns: true if successfully opened, false otherwise.
*/
bool FtdiDevice::open( const char* description, const char* serial, int index )
{
hasFtdiError_ = false;
if ( isOpen() ) {
hasFtdiError_ = false;
return false;
}
context_ = ftdi_new();
if ( context_ == 0 ) {
hasFtdiError_ = true;
return false;
}
bool success = false;
vec_deviceInfo* devs = const_cast<vec_deviceInfo*>( getDeviceList( context_ ) );
vec_deviceInfo::iterator it;
if ( devs != 0 ) {
for ( it = devs->begin(); it != devs->end(); ++it ) {
const deviceInfo& di = *it;
if ( description != 0 || serial != 0 ) {
if ( di.usbInfo == 0 )
break;
if ( description != 0 && std::strncmp( di.usbInfo->description, description,
std::strlen( description ) ) != 0 )
continue;
if ( serial != 0 && std::strncmp( di.usbInfo->serial, serial,
std::strlen( serial ) ) != 0 )
continue;
}
if ( index-- != 0 )
continue;
//If control gets here, we have found a suitable device.
if ( ftdi_usb_open_dev( context_, di.ftdiDevice ) < 0 ) {
//do not free context since that would also free the error message
hasFtdiError_ = true;
}
usbInfo_ = new usbInformation( *( di.usbInfo ) );
success = true;
}
} else {
hasFtdiError_ = ( devs == 0 );
}
if ( ! success && ! hasFtdiError_ ) {
delete context_; context_ = 0;
}
if ( success ) {
purgeBuffers();
reset();
}
return success;
}
