USB2.cpp

/*----- PROTECTED REGION ID(USB2.cpp) ENABLED START -----*/
//=============================================================================
//
// file :        USB2.cpp
//
// description : C++ source for the USB2 class and its commands.
//               The class is derived from Device. It represents the
//               CORBA servant object which will be accessed from the
//               network. All commands which can be executed on the
//               USB2 are implemented in this file.
//
// project :     
//
// This file is part of Tango device class.
// 
// Tango is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// Tango is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Tango.  If not, see <http://www.gnu.org/licenses/>.
// 
// $Author: alessio $
//
// $Revision: 1.5 $
// $Date: 2018-10-24 08:12:41 $
//
// $HeadURL:  $
//
//=============================================================================
//                This file is generated by POGO
//        (Program Obviously used to Generate tango Object)
//=============================================================================


#include <USB2.h>
#include <USB2Class.h>

#include <csignal>

/*----- PROTECTED REGION END -----*/	//	USB2.cpp

/**
 *  USB2 class description:
 *    
 */

//================================================================
//  The following table gives the correspondence
//  between command and method names.
//
//  Command name  |  Method name
//================================================================
//  Write         |  write
//  Read          |  read
//  ReadUntil     |  read_until
//================================================================

//================================================================
//  Attributes managed are:
//================================================================
//  InputLength    |  Tango::DevLong	Scalar
//  OutputLength   |  Tango::DevLong	Scalar
//  Reconnections  |  Tango::DevLong	Scalar
//================================================================

namespace USB2_ns
{
/*----- PROTECTED REGION ID(USB2::namespace_starting) ENABLED START -----*/

//	static initializations

/*----- PROTECTED REGION END -----*/	//	USB2::namespace_starting

//--------------------------------------------------------
/**
 *	Method     : USB2::USB2()
 *	Description: Constructors for a Tango device
 *                implementing the classUSB2
 */
//--------------------------------------------------------
USB2::USB2(Tango::DeviceClass *cl, std::string &s)
 : TANGO_BASE_CLASS(cl, s.c_str())
{
	/*----- PROTECTED REGION ID(USB2::constructor_1) ENABLED START -----*/
	init_device();
	
	/*----- PROTECTED REGION END -----*/	//	USB2::constructor_1
}
//--------------------------------------------------------
USB2::USB2(Tango::DeviceClass *cl, const char *s)
 : TANGO_BASE_CLASS(cl, s)
{
	/*----- PROTECTED REGION ID(USB2::constructor_2) ENABLED START -----*/
	init_device();
	
	/*----- PROTECTED REGION END -----*/	//	USB2::constructor_2
}
//--------------------------------------------------------
USB2::USB2(Tango::DeviceClass *cl, const char *s, const char *d)
 : TANGO_BASE_CLASS(cl, s, d)
{
	/*----- PROTECTED REGION ID(USB2::constructor_3) ENABLED START -----*/
	init_device();
	
	/*----- PROTECTED REGION END -----*/	//	USB2::constructor_3
}
//--------------------------------------------------------
USB2::~USB2()
{
	delete_device();
}

//--------------------------------------------------------
/**
 *	Method     : USB2::delete_device()
 *	Description: will be called at device destruction or at init command
 */
//--------------------------------------------------------
void USB2::delete_device()
{
	DEBUG_STREAM << "USB2::delete_device() " << device_name << std::endl;
	/*----- PROTECTED REGION ID(USB2::delete_device) ENABLED START -----*/
	
	//	Delete device allocated objects
	close();

	/*----- PROTECTED REGION END -----*/	//	USB2::delete_device
	delete[] attr_InputLength_read;
	delete[] attr_OutputLength_read;
	delete[] attr_Reconnections_read;
}

//--------------------------------------------------------
/**
 *	Method     : USB2::init_device()
 *	Description: will be called at device initialization.
 */
//--------------------------------------------------------
void USB2::init_device()
{
	DEBUG_STREAM << "USB2::init_device() create device " << device_name << std::endl;
	/*----- PROTECTED REGION ID(USB2::init_device_before) ENABLED START -----*/
	
	//	Initialization before get_device_property() call
	reconnections = 0;
	ctx = NULL;
	dev_handle = NULL;
	init_error.clear();
	conn_state = 0;
	/*----- PROTECTED REGION END -----*/	//	USB2::init_device_before


	//	Get the device properties from database
	get_device_property();

	attr_InputLength_read = new Tango::DevLong[1];
	attr_OutputLength_read = new Tango::DevLong[1];
	attr_Reconnections_read = new Tango::DevLong[1];
	//	No longer if mandatory property not set.
	if (mandatoryNotDefined)
		return;

	/*----- PROTECTED REGION ID(USB2::init_device) ENABLED START -----*/

	// Disabling SIGPIPE signal
	if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
		init_error = "Fail to ignore SIGPIPE signal";

	// Initialize device
	if (init_error.empty()) {
		open();
		check_state();
	}
	/*----- PROTECTED REGION END -----*/	//	USB2::init_device
}

//--------------------------------------------------------
/**
 *	Method     : USB2::get_device_property()
 *	Description: Read database to initialize property data members.
 */
//--------------------------------------------------------
void USB2::get_device_property()
{
	/*----- PROTECTED REGION ID(USB2::get_device_property_before) ENABLED START -----*/
	
	//	Initialize property data members
	
	/*----- PROTECTED REGION END -----*/	//	USB2::get_device_property_before

	mandatoryNotDefined = false;

	//	Read device properties from database.
	Tango::DbData	dev_prop;
	dev_prop.push_back(Tango::DbDatum("Timeout"));
	dev_prop.push_back(Tango::DbDatum("VendorID"));
	dev_prop.push_back(Tango::DbDatum("ProductID"));
	dev_prop.push_back(Tango::DbDatum("Interface"));
	dev_prop.push_back(Tango::DbDatum("EndpointUP"));
	dev_prop.push_back(Tango::DbDatum("EndpointDOWN"));
	dev_prop.push_back(Tango::DbDatum("MaxPacketSize"));

	//	is there at least one property to be read ?
	if (dev_prop.size()>0)
	{
		//	Call database and extract values
		if (Tango::Util::instance()->_UseDb==true)
			get_db_device()->get_property(dev_prop);

		//	get instance on USB2Class to get class property
		Tango::DbDatum	def_prop, cl_prop;
		USB2Class	*ds_class =
			(static_cast<USB2Class *>(get_device_class()));
		int	i = -1;

		//	Try to initialize Timeout from class property
		cl_prop = ds_class->get_class_property(dev_prop[++i].name);
		if (cl_prop.is_empty()==false)	cl_prop  >>  timeout;
		else {
			//	Try to initialize Timeout from default device value
			def_prop = ds_class->get_default_device_property(dev_prop[i].name);
			if (def_prop.is_empty()==false)	def_prop  >>  timeout;
		}
		//	And try to extract Timeout value from database
		if (dev_prop[i].is_empty()==false)	dev_prop[i]  >>  timeout;
		//	Property StartDsPath is mandatory, check if has been defined in database.
		check_mandatory_property(cl_prop, dev_prop[i]);

		//	Try to initialize VendorID from class property
		cl_prop = ds_class->get_class_property(dev_prop[++i].name);
		if (cl_prop.is_empty()==false)	cl_prop  >>  vendorID;
		else {
			//	Try to initialize VendorID from default device value
			def_prop = ds_class->get_default_device_property(dev_prop[i].name);
			if (def_prop.is_empty()==false)	def_prop  >>  vendorID;
		}
		//	And try to extract VendorID value from database
		if (dev_prop[i].is_empty()==false)	dev_prop[i]  >>  vendorID;
		//	Property StartDsPath is mandatory, check if has been defined in database.
		check_mandatory_property(cl_prop, dev_prop[i]);

		//	Try to initialize ProductID from class property
		cl_prop = ds_class->get_class_property(dev_prop[++i].name);
		if (cl_prop.is_empty()==false)	cl_prop  >>  productID;
		else {
			//	Try to initialize ProductID from default device value
			def_prop = ds_class->get_default_device_property(dev_prop[i].name);
			if (def_prop.is_empty()==false)	def_prop  >>  productID;
		}
		//	And try to extract ProductID value from database
		if (dev_prop[i].is_empty()==false)	dev_prop[i]  >>  productID;
		//	Property StartDsPath is mandatory, check if has been defined in database.
		check_mandatory_property(cl_prop, dev_prop[i]);

		//	Try to initialize Interface from class property
		cl_prop = ds_class->get_class_property(dev_prop[++i].name);
		if (cl_prop.is_empty()==false)	cl_prop  >>  interface;
		else {
			//	Try to initialize Interface from default device value
			def_prop = ds_class->get_default_device_property(dev_prop[i].name);
			if (def_prop.is_empty()==false)	def_prop  >>  interface;
		}
		//	And try to extract Interface value from database
		if (dev_prop[i].is_empty()==false)	dev_prop[i]  >>  interface;
		//	Property StartDsPath is mandatory, check if has been defined in database.
		check_mandatory_property(cl_prop, dev_prop[i]);

		//	Try to initialize EndpointUP from class property
		cl_prop = ds_class->get_class_property(dev_prop[++i].name);
		if (cl_prop.is_empty()==false)	cl_prop  >>  endpointUP;
		else {
			//	Try to initialize EndpointUP from default device value
			def_prop = ds_class->get_default_device_property(dev_prop[i].name);
			if (def_prop.is_empty()==false)	def_prop  >>  endpointUP;
		}
		//	And try to extract EndpointUP value from database
		if (dev_prop[i].is_empty()==false)	dev_prop[i]  >>  endpointUP;
		//	Property StartDsPath is mandatory, check if has been defined in database.
		check_mandatory_property(cl_prop, dev_prop[i]);

		//	Try to initialize EndpointDOWN from class property
		cl_prop = ds_class->get_class_property(dev_prop[++i].name);
		if (cl_prop.is_empty()==false)	cl_prop  >>  endpointDOWN;
		else {
			//	Try to initialize EndpointDOWN from default device value
			def_prop = ds_class->get_default_device_property(dev_prop[i].name);
			if (def_prop.is_empty()==false)	def_prop  >>  endpointDOWN;
		}
		//	And try to extract EndpointDOWN value from database
		if (dev_prop[i].is_empty()==false)	dev_prop[i]  >>  endpointDOWN;
		//	Property StartDsPath is mandatory, check if has been defined in database.
		check_mandatory_property(cl_prop, dev_prop[i]);

		//	Try to initialize MaxPacketSize from class property
		cl_prop = ds_class->get_class_property(dev_prop[++i].name);
		if (cl_prop.is_empty()==false)	cl_prop  >>  maxPacketSize;
		else {
			//	Try to initialize MaxPacketSize from default device value
			def_prop = ds_class->get_default_device_property(dev_prop[i].name);
			if (def_prop.is_empty()==false)	def_prop  >>  maxPacketSize;
		}
		//	And try to extract MaxPacketSize value from database
		if (dev_prop[i].is_empty()==false)	dev_prop[i]  >>  maxPacketSize;
		//	Property StartDsPath is mandatory, check if has been defined in database.
		check_mandatory_property(cl_prop, dev_prop[i]);

	}

	/*----- PROTECTED REGION ID(USB2::get_device_property_after) ENABLED START -----*/
	
	//	Check device property data members init
	vid = stoi(vendorID, NULL, 16);
	pid = stoi(productID, NULL, 16);

	ep_up = stoi(endpointUP, NULL, 16);
	ep_down = stoi(endpointDOWN, NULL, 16);

	if (timeout <= 0)
		timeout = 1000;

	DEBUG_STREAM << "Connecting to " << productID << " of the " << vendorID 
		<< " using " << interface << " with MaxPacketSize " << maxPacketSize
		<< " on "<< endpointUP << " " << endpointDOWN 
		<<  " with a timeout of " << timeout << " ms "<< endl;

	timeout_timeval.tv_sec = timeout / 1000;
	timeout_timeval.tv_usec = timeout % 1000 * 1000;

	/*----- PROTECTED REGION END -----*/	//	USB2::get_device_property_after
}
//--------------------------------------------------------
/**
 *	Method     : USB2::check_mandatory_property()
 *	Description: For mandatory properties check if defined in database.
 */
//--------------------------------------------------------
void USB2::check_mandatory_property(Tango::DbDatum &class_prop, Tango::DbDatum &dev_prop)
{
	//	Check if all properties are empty
	if (class_prop.is_empty() && dev_prop.is_empty())
	{
		TangoSys_OMemStream	tms;
		tms << std::endl <<"Property \'" << dev_prop.name;
		if (Tango::Util::instance()->_UseDb==true)
			tms << "\' is mandatory but not defined in database";
		else
			tms << "\' is mandatory but cannot be defined without database";
		append_status(tms.str());
		mandatoryNotDefined = true;
		/*----- PROTECTED REGION ID(USB2::check_mandatory_property) ENABLED START -----*/
		cerr << tms.str() << " for " << device_name << endl;
		
		/*----- PROTECTED REGION END -----*/	//	USB2::check_mandatory_property
	}
}


//--------------------------------------------------------
/**
 *	Method     : USB2::always_executed_hook()
 *	Description: method always executed before any command is executed
 */
//--------------------------------------------------------
void USB2::always_executed_hook()
{
	DEBUG_STREAM << "USB2::always_executed_hook()  " << device_name << std::endl;
	if (mandatoryNotDefined)
	{
		Tango::Except::throw_exception(
					(const char *)"PROPERTY_NOT_SET",
					get_status().c_str(),
					(const char *)"USB2::always_executed_hook()");
	}
	/*----- PROTECTED REGION ID(USB2::always_executed_hook) ENABLED START -----*/
	
	//	code always executed before all requests
	tout = timeout_timeval;

	if (! init_error.empty()) {
		set_state(Tango::FAULT);
		set_status(init_error);
		DEBUG_STREAM << init_error << endl;
		return;
	}

	check_state();

	/*----- PROTECTED REGION END -----*/	//	USB2::always_executed_hook
}

//--------------------------------------------------------
/**
 *	Method     : USB2::read_attr_hardware()
 *	Description: Hardware acquisition for attributes
 */
//--------------------------------------------------------
void USB2::read_attr_hardware(TANGO_UNUSED(std::vector<long> &attr_list))
{
	DEBUG_STREAM << "USB2::read_attr_hardware(std::vector<long> &attr_list) entering... " << std::endl;
	/*----- PROTECTED REGION ID(USB2::read_attr_hardware) ENABLED START -----*/
	
	//	Add your own code
	
	/*----- PROTECTED REGION END -----*/	//	USB2::read_attr_hardware
}

//--------------------------------------------------------
/**
 *	Read attribute InputLength related method
 *
 *
 *	Data type:	Tango::DevLong
 *	Attr type:	Scalar
 */
//--------------------------------------------------------
void USB2::read_InputLength(Tango::Attribute &attr)
{
	DEBUG_STREAM << "USB2::read_InputLength(Tango::Attribute &attr) entering... " << std::endl;
	/*----- PROTECTED REGION ID(USB2::read_InputLength) ENABLED START -----*/
	//	Set the attribute value
	Tango::AttrQuality qual;
	long len = input_queue_length();
	if (len >= 0) {
		qual = Tango::ATTR_VALID;
		attr_InputLength_read[0] = len + data.size(); 
	} else {
		qual = Tango::ATTR_INVALID;
		attr_InputLength_read[0] = data.size();
	}
	attr.set_value_date_quality(attr_InputLength_read, time(NULL), qual);
	/*----- PROTECTED REGION END -----*/	//	USB2::read_InputLength
}
//--------------------------------------------------------
/**
 *	Read attribute OutputLength related method
 *
 *
 *	Data type:	Tango::DevLong
 *	Attr type:	Scalar
 */
//--------------------------------------------------------
void USB2::read_OutputLength(Tango::Attribute &attr)
{
	DEBUG_STREAM << "USB2::read_OutputLength(Tango::Attribute &attr) entering... " << std::endl;
	/*----- PROTECTED REGION ID(USB2::read_OutputLength) ENABLED START -----*/
	//	Set the attribute value
	Tango::AttrQuality qual;
	long len = output_queue_length();
	if (len >= 0) {
		qual = Tango::ATTR_VALID;
		attr_OutputLength_read[0] = len;
	}	else {
		qual = Tango::ATTR_INVALID;
		attr_OutputLength_read[0] = 0;
	}
	attr.set_value_date_quality(attr_OutputLength_read, time(NULL), qual);
	/*----- PROTECTED REGION END -----*/	//	USB2::read_OutputLength
}
//--------------------------------------------------------
/**
 *	Read attribute Reconnections related method
 *
 *
 *	Data type:	Tango::DevLong
 *	Attr type:	Scalar
 */
//--------------------------------------------------------
void USB2::read_Reconnections(Tango::Attribute &attr)
{
	DEBUG_STREAM << "USB2::read_Reconnections(Tango::Attribute &attr) entering... " << std::endl;
	/*----- PROTECTED REGION ID(USB2::read_Reconnections) ENABLED START -----*/
	//	Set the attribute value
	attr_Reconnections_read[0] = reconnections;
	attr.set_value(attr_Reconnections_read);
	
	/*----- PROTECTED REGION END -----*/	//	USB2::read_Reconnections
}

//--------------------------------------------------------
/**
 *	Method     : USB2::add_dynamic_attributes()
 *	Description: Create the dynamic attributes if any
 *                for specified device.
 */
//--------------------------------------------------------
void USB2::add_dynamic_attributes()
{
	/*----- PROTECTED REGION ID(USB2::add_dynamic_attributes) ENABLED START -----*/
	
	//	Add your own code to create and add dynamic attributes if any
	
	/*----- PROTECTED REGION END -----*/	//	USB2::add_dynamic_attributes
}

//--------------------------------------------------------
/**
 *	Command Write related method
 *
 *
 *	@param argin
 */
//--------------------------------------------------------
void USB2::write(const Tango::DevVarCharArray *argin)
{
	DEBUG_STREAM << "USB2::Write()  - " << device_name << std::endl;
	/*----- PROTECTED REGION ID(USB2::write) ENABLED START -----*/
	vector<unsigned char> argin_data;
	argin_data << *argin;
	size_t bytes_total = 0, bytes_to_write = argin_data.size();

	if (! init_error.empty()) {
		sleep(tout);
		Tango::Except::throw_exception(
				"", init_error.c_str(), __PRETTY_FUNCTION__);
	}

	if (max(output_queue_length(), 0) != 0 || ! dev_handle)
		goto error;
	
	while (bytes_total < bytes_to_write) {
		int bytes_written;
		conn_state = libusb_bulk_transfer(dev_handle, ep_down, 
				argin_data.data() + bytes_total,
				bytes_to_write - bytes_total, &bytes_written, timeout);
		if (conn_state == LIBUSB_ERROR_TIMEOUT)
			goto timeout;
		if ( bytes_written > 0) {
			bytes_total += bytes_written;
		} else if (bytes_written == 0) {
			goto error;
		} else { /* bytes_written < 0 */
			goto error;
		}
	}

	timeval twait;
	timerclear(&twait);
	twait.tv_usec = 1000;
	while (max(output_queue_length(), 0) != 0) {
		if (! sleep(twait))
			goto timeout;
		timeradd(&twait, &twait, &twait);
	}

	return;

error:
	check_state();
	sleep(tout);
timeout:
	Tango::Except::throw_exception(
			"", "Timeout expired", __PRETTY_FUNCTION__);

	/*----- PROTECTED REGION END -----*/	//	USB2::write
}
//--------------------------------------------------------
/**
 *	Command Read related method
 *
 *
 *	@param argin
 *	@returns
 */
//--------------------------------------------------------
Tango::DevVarCharArray *USB2::read(Tango::DevLong argin)
{
	Tango::DevVarCharArray *argout;
	DEBUG_STREAM << "USB2::Read()  - " << device_name << std::endl;
	/*----- PROTECTED REGION ID(USB2::read) ENABLED START -----*/
	if (! init_error.empty()) {
		sleep(tout);
		Tango::Except::throw_exception(
				"", init_error.c_str(), __PRETTY_FUNCTION__);
	}

	if (argin < 0) {
		sleep(tout);
		Tango::Except::throw_exception(
				"", "Out of limit", __PRETTY_FUNCTION__);
	}

	_read(argin);

	argout = new Tango::DevVarCharArray();
	vector<unsigned char> transfer(data.begin(), data.begin() + argin);
	data.erase(data.begin(), data.begin() + argin);
	*argout << transfer;
	/*----- PROTECTED REGION END -----*/	//	USB2::read
	return argout;
}
//--------------------------------------------------------
/**
 *	Command ReadUntil related method
 *
 *
 *	@param argin
 *	@returns
 */
//--------------------------------------------------------
Tango::DevVarCharArray *USB2::read_until(const Tango::DevVarCharArray *argin)
{
	Tango::DevVarCharArray *argout;
	DEBUG_STREAM << "USB2::ReadUntil()  - " << device_name << std::endl;
	/*----- PROTECTED REGION ID(USB2::read_until) ENABLED START -----*/
	if (! init_error.empty()) {
		sleep(tout);
		Tango::Except::throw_exception(
				"", init_error.c_str(), __PRETTY_FUNCTION__);
	}

	if (argin->length() != 1) {
		sleep(tout);
		Tango::Except::throw_exception(
				"", "Delimiter has to be exactly one byte", __PRETTY_FUNCTION__);
	}

	char delim = (*argin)[0];
	size_t pos = 0, dsize;
	bool found = false;

	do {
		dsize = data.size();
		for (; pos < dsize; ++pos) {
			if (memcmp(&data[pos], &delim, 1) == 0)	{
				found = true;
				break;
			}
		}
		if (found)
			break;
		_read(dsize + 1);
	} while (true);

	argout = new Tango::DevVarCharArray();
	vector<unsigned char> transfer(data.begin(), data.begin() + pos +1);
	data.erase(data.begin(), data.begin() + pos + 1);
	*argout << transfer;
	/*----- PROTECTED REGION END -----*/	//	USB2::read_until
	return argout;
}
//--------------------------------------------------------
/**
 *	Method     : USB2::add_dynamic_commands()
 *	Description: Create the dynamic commands if any
 *                for specified device.
 */
//--------------------------------------------------------
void USB2::add_dynamic_commands()
{
	/*----- PROTECTED REGION ID(USB2::add_dynamic_commands) ENABLED START -----*/
	
	//	Add your own code to create and add dynamic commands if any
	
	/*----- PROTECTED REGION END -----*/	//	USB2::add_dynamic_commands
}

/*----- PROTECTED REGION ID(USB2::namespace_ending) ENABLED START -----*/

//	Additional Methods
bool USB2::sleep(timeval tv)
{
	if (! timerisset(&tout))
		return false;

	if (timercmp(&tout, &tv, <)) {
		::sleep(tout.tv_sec);
		usleep(tout.tv_usec);
		timerclear(&tout);
	} else { // tout >= tv
		::sleep(tv.tv_sec);
		usleep(tv.tv_usec);
		timersub(&tout, &tv, &tout);
		assert(tout.tv_sec >= 0 && tout.tv_usec >= 0);
	}
	return true;
}

void USB2::open()
{
	DEBUG_STREAM << "Opening USB device..." << endl;

	if(libusb_init(&ctx) < 0) {
		ERROR_STREAM << "Failed to initialize libusb" << endl;
		return;
	}

#ifndef NDEBUG
	libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_WARNING);
#endif

	dev_handle = libusb_open_device_with_vid_pid(ctx, vid, pid);
	if(dev_handle == NULL) {
		libusb_exit(ctx);

		ERROR_STREAM << "Unable to open device" << endl;
		return;
	}

	int ret = libusb_claim_interface(dev_handle, interface);
	if(ret < 0) {
		libusb_release_interface(dev_handle, interface);
		libusb_close(dev_handle);
		libusb_exit(ctx);
		ERROR_STREAM << "Failed to claim interface" << endl;
		return;
	}

}

int USB2::input_queue_length()
{
	return data.size();
}

int USB2::output_queue_length()
{
	return 0;
}

void USB2::close()
{
	DEBUG_STREAM << "Closing USB device..." << endl;

	int output_len = max(output_queue_length(), 0);
	int input_len = max(input_queue_length(), 0) + data.size();

	if(input_len + output_len)
	{
		WARN_STREAM << " Bytes dropped: " << input_len << " input, "
			<< output_len << " output" << endl;
	}

	if(dev_handle)
	{
		libusb_release_interface(dev_handle, interface);
		libusb_close(dev_handle);
		libusb_exit(ctx);

		dev_handle = NULL;
	}

	data.clear();
}

void USB2::_read(size_t bytes_to_read)
{
	unsigned char buffer[10000];
	size_t bytes_total = data.size();
	int bytes_readed;

	if (! dev_handle)
		goto error;

	while (bytes_total < bytes_to_read) {
		conn_state = libusb_bulk_transfer(dev_handle, ep_up, buffer,
				maxPacketSize, &bytes_readed, timeout);
		if (conn_state == LIBUSB_ERROR_TIMEOUT)
			goto timeout;
		if (bytes_readed > 0) {
			data.insert(data.end(), &buffer[0], &buffer[bytes_readed]);
			bytes_total += bytes_readed;
		} else if (bytes_readed == 0) {
			goto error;
		} else { /* bytes_readed < 0 */
			goto error;
		}
	}
	return;
error:
	check_state();
	sleep(tout);
timeout:
	Tango::Except::throw_exception(
			"", "Timeout expired", __PRETTY_FUNCTION__);
}

void USB2::check_state()
{
	string mesg;
	switch(conn_state)
	{
		case 0: /* Success */
			set_state(Tango::ON);
			set_status("Connected");
			return;
		case LIBUSB_ERROR_TIMEOUT:
			return;
		case LIBUSB_ERROR_PIPE:
			mesg = "Pipe error";
			break;
		case LIBUSB_ERROR_OVERFLOW:
			mesg = "Overflow error";
			break;
		case LIBUSB_ERROR_NO_DEVICE:
			mesg = "No device error";
			break;
		case LIBUSB_ERROR_BUSY:
			mesg = "Busy error";
			break;
		case LIBUSB_ERROR_INVALID_PARAM:
			mesg = "Invalid parameter error";
			break;
		default:
			ERROR_STREAM << "USB error " << conn_state
				<< " not handled!" << endl;
			assert(false);
			break;
	}

	set_state(Tango::INIT);
	set_status("Reconnecting due: " + mesg);
	DEBUG_STREAM << "Reconnecting due: " << mesg << endl;

	close();
	open();
	reconnections += 1;
}

/*----- PROTECTED REGION END -----*/	//	USB2::namespace_ending
} //	namespace