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>

/*----- 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 -----*/
	reconnections = -1;
	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 -----*/
	reconnections = -1;
	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 -----*/
	reconnections = -1;
	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 -----*/
	
	close();
	delete[] buffer;

	/*----- 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
	ctx = NULL;
	dev_handle = NULL;
	buffer = NULL;
	init_error.clear();
	
	/*----- 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 -----*/

	//	Initialize device
	try
	{
		buffer = new unsigned char[maxPacketSize];
		open();
	}
	catch (Tango::DevFailed &e)
	{
		init_error = "Initialization failed: " + string(e.errors[0].desc);
	}
	catch (...)
	{
		init_error = "Initialization failed: Unknown error";
	}

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

	/*----- 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
	if (! init_error.empty())
	{
		set_state(Tango::FAULT);
		set_status(init_error);
		return;
	}

	try {
		if (! dev_handle) {
			open();
		}
	} catch(Tango::DevFailed &e) {
		set_state(Tango::FAULT);
		set_status(string(e.errors[0].desc));
	} catch(...) {
		set_state(Tango::FAULT);
		set_status("The device is in FAULT state for unknown reason");
	}

	/*----- 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
	attr_InputLength_read[0] = input_queue_length(); 
	attr.set_value(attr_InputLength_read);
	
	/*----- 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
	attr_OutputLength_read[0] = output_queue_length();
	attr.set_value(attr_OutputLength_read);
	
	/*----- 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 -----*/
	
	check_init();

	if(!timeout) {
		Tango::Except::throw_exception( "",
				"Invalid timeout",
				"USB2::write()");
	}

	unsigned char *argin_data = new unsigned char[argin->length()];
	for(unsigned int i=0; i<argin->length(); ++i)
	{
		argin_data[i] = (*argin)[i];
	}

	int bytes_total = 0, bytes_to_write  = argin->length();
	while(bytes_total != bytes_to_write) {
		int bytes_written;
		int ret = libusb_bulk_transfer(dev_handle,
				ep_down, argin_data + bytes_total,
				bytes_to_write - bytes_total, &bytes_written, timeout);

		if(ret != 0 || bytes_written != bytes_to_write - bytes_total) {
			delete argin_data;

			string error_mesg = "Unable to send request to device";

			close();
			open();
			DEBUG_STREAM << error_mesg << endl;
			set_state( Tango::FAULT );
			set_status( error_mesg );

			Tango::Except::throw_exception( "",
					error_mesg,
					"USB2::write()");
		}
		bytes_total += bytes_written;
	}
	delete argin_data;

	/*----- 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 -----*/
	
	check_init();
	
	if(!timeout) {
		Tango::Except::throw_exception( "",
				"Invalid timeout",
				"USB2::write()");
	}
	
	if (argin < 0)
	{
		Tango::Except::throw_exception("",
				"Input has to be in positive range",
				"USB2::read()");
	}

	while( (size_t)argin > data.size() )
	{
		int bytes_readed;
		int ret = libusb_bulk_transfer(dev_handle, ep_up, buffer,
				maxPacketSize, &bytes_readed, timeout);
		if(ret != 0 || bytes_readed == 0) {
			string error_mesg( "No response from device" );
			DEBUG_STREAM << error_mesg << endl;
			Tango::Except::throw_exception("",
					error_mesg, "USB2::read()");
		}

		for(int i=0;i<bytes_readed;++i) {
			data.push_back(buffer[i]);
		}
	}

	argout = new Tango::DevVarCharArray();
	argout->length(argin);
	for( int i=0; i<argin; ++i )
	{
		(*argout)[i] = data[i];
	}
	data.erase( data.begin(), data.begin() + argin );

	/*----- 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 -----*/
	
	check_init();
	
	if(!timeout) {
		Tango::Except::throw_exception( "",
				"Invalid timeout",
				"USB2::write()");
	}
	
	if (argin->length() != 1)
	{
		Tango::Except::throw_exception("",
				"Delimiter has to be one byte length",
				"USB2::read_until()");
	}

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

	while( ! found )
	{
		for( pos = 0; pos < data.size(); ++pos )
		{
			if (memcmp(&data[pos], &delim, 1) == 0)
			{
				found = true;
				break;
			}
		}
		if ( ! found )
		{
			int bytes_readed;
			int ret = libusb_bulk_transfer(dev_handle, ep_up, buffer,
					maxPacketSize, &bytes_readed, timeout);
			if(ret != 0 || bytes_readed == 0) {
				string error_mesg( "No response from device" );
				DEBUG_STREAM << error_mesg << endl;
				Tango::Except::throw_exception("",
						error_mesg, "USB2::read_until()");
			}

			for(int i=0;i<bytes_readed;++i) {
				data.push_back(buffer[i]);
			}
		}
	}

	argout = new Tango::DevVarCharArray();
	argout->length( pos+1 );
	for( size_t i = 0; i < pos + 1; ++i )
	{
		(*argout)[i] = data[i];
	}
	data.erase( data.begin(), data.begin() + pos + 1 );

	/*----- 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
void USB2::check_init()
{
	if (! init_error.empty() )
	{
		DEBUG_STREAM << init_error << endl;
		Tango::Except::throw_exception( "",
				init_error.c_str(),
				"USB2::check_init()");
	}
}

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

	if(libusb_init(&ctx) < 0) {
		string error_mesg = "Failed to initialize libusb";
		ERROR_STREAM << error_mesg << endl;
		assert( false);
		Tango::Except::throw_exception( "",
				error_mesg,
				"USB2::open()");
	}

#ifndef NDEBUG
	libusb_set_debug(ctx, LIBUSB_LOG_LEVEL_WARNING);
#endif

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

		string error_mesg = "Unable to open device";
		ERROR_STREAM << error_mesg << endl;
		assert( false);
		Tango::Except::throw_exception( "",
				error_mesg,
				"USB2::open()");
	}

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

		string error_mesg = "Failed to claim interface";
		ERROR_STREAM << error_mesg << endl;
		assert( false);
		Tango::Except::throw_exception( "",
				error_mesg,
				"USB2::open()");
	}
  
	DEBUG_STREAM << "USB device opened." << endl;
	reconnections++;

	set_state(Tango::ON);
	set_status("The device in ON state");
}

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

	int input_len = input_queue_length();
	int output_len = output_queue_length();

	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();

	DEBUG_STREAM << "USB device closed" << endl;
}

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

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

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