/*
* 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;
}
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;
}
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;
}
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;
}
/**
* 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;
}
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));
}
}
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;
}
/*-----------------------------------------------------------------------------
* 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;
}
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;
}
int Context::open(int vendor, int product)
{
// Open device
int ret = ftdi_usb_open(d->ftdi, vendor, product);
if (ret < 0)
return ret;
return get_strings_and_reopen();
}
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 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 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 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;
}
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
}
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;
}
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;
}
}
}
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;
}
//Try to find the ftdi chip and open it.
int FtdiNand::open(int vid, int pid, bool doslow) {
unsigned char slow=DIS_DIV_5;
if (doslow) slow=EN_DIV_5;
m_slowAccess=doslow;
//If vid/pid is zero, use default FT2232H vid/pid.
if (vid==0) vid=0x0403;
if (pid==0) pid=0x6010;
//Open FTDI communications
if (ftdi_init(&m_ftdi)<0) return error("init");
if (ftdi_usb_open(&m_ftdi, vid, pid)<0) return error("open");
if (ftdi_set_bitmode(&m_ftdi, 0, BITMODE_MCU)<0) error("bitmode");
if (ftdi_write_data(&m_ftdi, &slow, 1)<0) return error("writing div5 cmd");
if (ftdi_set_latency_timer(&m_ftdi, 1)<0) return error("setting latency");
ftdi_usb_purge_buffers(&m_ftdi);
return 1;
}
int main(void) {
snd_rawmidi_open(&midi_in, &midi_out, "virtual", SND_RAWMIDI_NONBLOCK);
//snd_rawmidi_open(&midi_in, &midi_out, "virtual", 0);
if (ftdi_init( &ftdi )) {
fprintf(stderr, "usb - init error !\n");
return 1;
}
if (ftdi_usb_open(&ftdi, 0x0403, 0x6001)) {
fprintf(stderr, "usb - open error (cannot find?) !\n");
fprintf(stderr, "ftdi_usb_open failed, error (%s)\n", ftdi_get_error_string(&ftdi));
ftdi_deinit( &ftdi );
return 2;
}
if (ftdi_usb_reset( &ftdi )) {
fprintf(stderr, "usb - reset error !\n");
ftdi_usb_close( &ftdi );
ftdi_deinit( &ftdi );
return 3;
}
ftdi_disable_bitbang( &ftdi );
ftdi_set_baudrate(&ftdi, BAUD);
unsigned char buf[BUFFER_SIZE];
int ret;
while(1) {
//FTDI2MIDI
ret = ftdi_read_data(&ftdi, buf, BUFFER_SIZE);
if(ret < 0) break;
if(ret > 0) snd_rawmidi_write(midi_out, buf, BUFFER_SIZE);
//MIDI2FTDI
/*
ret = snd_rawmidi_read(midi_in, buf,BUFFER_SIZE);
if(ret < 0 && ret != -EAGAIN) break;
if(ret > 0) ftdi_write_data(&ftdi, buf,BUFFER_SIZE);
*/
usleep(LATENCY);
}
exit(0);
}
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;
}
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);
}
bool QLCFTDI::openByPID(const int PID)
{
if (m_openCount < m_refCount)
m_openCount++;
if (isOpen() == true)
return true;
if (ftdi_usb_open(&m_handle, QLCFTDI::VID, PID) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
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(void)
{
int ret;
struct ftdi_context ftdic;
if (ftdi_init(&ftdic) < 0)
{
fprintf(stderr, "ftdi_init failed\n");
return EXIT_FAILURE;
}
if ((ret = ftdi_usb_open(&ftdic, 0x15ba, 0x002a)) < 0)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return EXIT_FAILURE;
}
// Read out FTDIChip-ID of R type chips
if (ftdic.type == TYPE_R)
{
unsigned int chipid;
printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(&ftdic, &chipid));
printf("FTDI chipid: %X\n", chipid);
}
ftdi_set_bitmode(&ftdic, 0x0b, BITMODE_MPSSE); /* ctx, JTAG I/O mask */
write_ftdi_command(&ftdic, SET_BITS_LOW, 0x00, 0x0b);
write_ftdi_command(&ftdic, SET_BITS_HIGH, OLIMEX_CBUS_nSRST, OLIMEX_CBUS_nSRST|OLIMEX_CBUS_LED);
usleep(100);
write_ftdi_command(&ftdic, SET_BITS_HIGH, OLIMEX_CBUS_LED, OLIMEX_CBUS_nSRST|OLIMEX_CBUS_LED);
usleep(1500000);
write_ftdi_command(&ftdic, SET_BITS_LOW, 0x00, 0x00);
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;
}
