Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/*----- 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>
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
/*----- 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 -----*/
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
ctx = NULL;
dev_handle = 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 -----*/
// Disabling SIGPIPE signal
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
init_error = "Fail to ignore SIGPIPE signal";
// Initialize device
if (init_error.empty()) {
}
/*----- PROTECTED REGION END -----*/ // USB2::init_device
}
//--------------------------------------------------------
/**
* Method : USB2::get_device_property()
* Description: Read database to initialize property data members.
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
*/
//--------------------------------------------------------
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);
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
// 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";
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",
(const char *)"USB2::always_executed_hook()");
}
/*----- PROTECTED REGION ID(USB2::always_executed_hook) ENABLED START -----*/
// code always executed before all requests
set_status(init_error);
DEBUG_STREAM << init_error << endl;
/*----- 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
*
*/
//--------------------------------------------------------
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)
conn_state = libusb_bulk_transfer(dev_handle, ep_down,
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) {
} 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:
sleep(tout);
timeout:
Tango::Except::throw_exception(
"", "Timeout expired", __PRETTY_FUNCTION__);
/*----- PROTECTED REGION END -----*/ // USB2::write
}
//--------------------------------------------------------
/**
* Command Read related method
*
*/
//--------------------------------------------------------
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__);
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
*
*/
//--------------------------------------------------------
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__);
do {
dsize = data.size();
for (; pos < dsize; ++pos) {
if (memcmp(&data[pos], &delim, 1) == 0) {
if (found)
break;
_read(dsize + 1);
} while (true);
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
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);
}
void USB2::open()
{
DEBUG_STREAM << "Opening USB device..." << endl;
if(libusb_init(&ctx) < 0) {
ERROR_STREAM << "Failed to initialize libusb" << endl;
return;
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();
{
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();
unsigned char buffer[10000];
size_t bytes_total = data.size();
int bytes_readed;
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;
}
}
return;
error:
sleep(tout);
timeout:
Tango::Except::throw_exception(
"", "Timeout expired", __PRETTY_FUNCTION__);
string mesg;
switch(conn_state)
{
case 0: /* Success */
set_state(Tango::ON);
set_status("Connected");
return;
case LIBUSB_ERROR_TIMEOUT:
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
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