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