private IEnumerator FreiburgPulse()
{
while (true)
{
yield return(new WaitForSeconds(Random.Range(TIME_BETWEEN_PULSES_MIN, TIME_BETWEEN_PULSES_MAX)));
int claimInterfaceResult = MonoUsbApi.ClaimInterface(freiburgSyncboxDeviceHandle, FREIBURG_SYNCBOX_INTERFACE_NUMBER);
int actual_length;
int bulkTransferResult = MonoUsbApi.BulkTransfer(freiburgSyncboxDeviceHandle, FREIBURG_SYNCBOX_ENDPOINT, byte.MinValue, FREIBURG_SYNCBOX_PIN_COUNT / 8, out actual_length, FREIBURG_SYNCBOX_TIMEOUT_MS);
if (bulkTransferResult == 0)
{
LogPulse();
}
Debug.Log("Sync pulse. " + actual_length.ToString() + " byte(s) written.");
MonoUsbApi.ReleaseInterface(freiburgSyncboxDeviceHandle, FREIBURG_SYNCBOX_INTERFACE_NUMBER);
if (claimInterfaceResult != 0 || bulkTransferResult != 0)
{
break;
}
}
Debug.Log("Restarting sync session.");
EndFreiburgSyncSession();
BeginFreiburgSyncSession();
}
private MonoUsbDeviceHandle getUsableAndOpenUsbHandle()
{
lock (_sync)
{
if (context != null)
{
if (!context.IsClosed)
{
context.Close();
}
context.Dispose();
context = null;
}
context = new MonoUsbSessionHandle();
var usbHandle = MonoUsbApi.OpenDeviceWithVidPid(context, 1406, 12288);
if (usbHandle != null)
{
if (MonoUsbApi.ClaimInterface(usbHandle, 0) == 0)
{
return(usbHandle);
}
usbHandle.Close();
}
UnityEngine.Debug.Log("Failed");
return(null);
}
}
/// <summary>
/// Claims the specified interface of the device.
/// </summary>
/// <param name="interfaceID">The interface to claim.</param>
/// <returns>True on success.</returns>
public bool ClaimInterface(int interfaceID)
{
int ret = MonoUsbApi.ClaimInterface((MonoUsbDeviceHandle)mUsbHandle, interfaceID);
if (ret != 0)
{
UsbError.Error(ErrorCode.MonoApiError, ret, "ClaimInterface Failed", this);
return(false);
}
mClaimedInteface = interfaceID;
return(true);
}
/// <summary>
/// Claims the specified interface of the device.
/// </summary>
/// <param name="interfaceID">The interface to claim.</param>
/// <returns>True on success.</returns>
public bool ClaimInterface(int interfaceID)
{
if (mClaimedInterfaces.Contains(interfaceID))
{
return(true);
}
int ret = MonoUsbApi.ClaimInterface((MonoUsbDeviceHandle)mUsbHandle, interfaceID);
if (ret != 0)
{
MonoUsbErrorMessage.Error(ErrorCode.MonoApiError, ret, "ClaimInterface Failed", this);
return(false);
}
mClaimedInterfaces.Add(interfaceID);
return(true);
}
// there is no connect, we just check if we can open and claim an interface, and if we can then we can "connect"
public bool Connect()
{
lock (_sync)
{
if (context != null)
{
if (!context.IsClosed)
{
context.Close();
}
context.Dispose();
context = null;
}
context = new MonoUsbSessionHandle();
var usbHandle = MonoUsbApi.OpenDeviceWithVidPid(context, 1406, 12288);
if (usbHandle != null)
{
if (MonoUsbApi.ClaimInterface(usbHandle, 0) == 0)
{
MonoUsbApi.ReleaseInterface(usbHandle, 0);
usbHandle.Close();
Connected = true;
return(true);
}
usbHandle.Close();
}
else
{
throw new Exception("Console not found or usb driver failed to open device. Is the console connected and is libusb configured correctly?");
}
Connected = false;
UnityEngine.Debug.Log("Failed");
return(false);
}
}
public static void ShowConfig(RichTextBox rtb)
{
// Assign the control transfer delegate to the callback function.
controlTransferDelegate = ControlTransferCB;
// Initialize the context.
sessionHandle = new MonoUsbSessionHandle();
if (sessionHandle.IsInvalid)
{
throw new Exception(String.Format("Failed intializing libusb context.\n{0}:{1}",
MonoUsbSessionHandle.LastErrorCode,
MonoUsbSessionHandle.LastErrorString));
}
MonoUsbProfileList profileList = new MonoUsbProfileList();
MonoUsbDeviceHandle myDeviceHandle = null;
try
{
// The list is initially empty.
// Each time refresh is called the list contents are updated.
profileList.Refresh(sessionHandle);
// Use the GetList() method to get a generic List of MonoUsbProfiles
// Find the first profile that matches in MyVidPidPredicate.
MonoUsbProfile myProfile = profileList.GetList().Find(MyVidPidPredicate);
if (myProfile == null)
{
rtb.AppendText("Device not connected.");
return;
}
// Open the device handle to perform I/O
myDeviceHandle = myProfile.OpenDeviceHandle();
if (myDeviceHandle.IsInvalid)
{
throw new Exception(String.Format("Failed opening device handle.\n{0}:{1}",
MonoUsbDeviceHandle.LastErrorCode,
MonoUsbDeviceHandle.LastErrorString));
}
int ret;
MonoUsbError e;
// Set Configuration
e = (MonoUsbError)(ret = MonoUsbApi.SetConfiguration(myDeviceHandle, 1));
if (ret < 0)
{
throw new Exception(String.Format("Failed SetConfiguration.\n{0}:{1}", e, MonoUsbApi.StrError(e)));
}
// Claim Interface
e = (MonoUsbError)(ret = MonoUsbApi.ClaimInterface(myDeviceHandle, 0));
if (ret < 0)
{
throw new Exception(String.Format("Failed ClaimInterface.\n{0}:{1}", e, MonoUsbApi.StrError(e)));
}
// Create a vendor specific control setup, allocate 1 byte for return control data.
byte requestType = (byte)(UsbCtrlFlags.Direction_In | UsbCtrlFlags.Recipient_Device | UsbCtrlFlags.RequestType_Vendor);
byte request = 0x0F;
MonoUsbControlSetupHandle controlSetupHandle = new MonoUsbControlSetupHandle(requestType, request, 0, 0, 1);
// Transfer the control setup packet
ret = libusb_control_transfer(myDeviceHandle, controlSetupHandle, 1000);
if (ret > 0)
{
rtb.AppendText("\nSuccess!\n");
byte[] ctrlDataBytes = controlSetupHandle.ControlSetup.GetData(ret);
string ctrlDataString = Helper.HexString(ctrlDataBytes, String.Empty, "h ");
rtb.AppendText(string.Format("Return Length: {0}", ret));
rtb.AppendText(string.Format("DATA (hex) : [ {0} ]\n", ctrlDataString.Trim()));
}
MonoUsbApi.ReleaseInterface(myDeviceHandle, 0);
}
finally
{
profileList.Close();
if (myDeviceHandle != null)
{
myDeviceHandle.Close();
}
sessionHandle.Close();
}
}
public static int Main(string[] args)
{
MonoUsbDeviceHandle device_handle = null;
int r = 0;
int transferred;
byte[] testWriteData = new byte[TEST_WRITE_LEN];
byte[] testReadData = new byte[TEST_READ_LEN];
if (args.Length > 0)
{
switch (args[0].ToLower())
{
case "sync":
TEST_MODE = TestMode.Sync;
break;
case "async":
TEST_MODE = TestMode.Async;
break;
}
}
fillTestData(testWriteData, TEST_WRITE_LEN);
memset(testReadData, 0, TEST_READ_LEN);
int loopCount = 0;
do
{
try
{
do
{
sessionHandle = new MonoUsbSessionHandle();
if (sessionHandle.IsInvalid)
{
throw new Exception("Invalid session handle.");
}
Console.WriteLine("Opening Device..");
device_handle = MonoUsbApi.OpenDeviceWithVidPid(sessionHandle, MY_VID, MY_PID);
if ((device_handle == null) || device_handle.IsInvalid)
{
break;
}
// If TEST_REST_DEVICE = True, reset the device and re-open
if (TEST_REST_DEVICE)
{
MonoUsbApi.ResetDevice(device_handle);
device_handle.Close();
device_handle = MonoUsbApi.OpenDeviceWithVidPid(sessionHandle, MY_VID, MY_PID);
if ((device_handle == null) || device_handle.IsInvalid)
{
break;
}
}
// Set configuration
Console.WriteLine("Set Config..");
r = MonoUsbApi.SetConfiguration(device_handle, MY_CONFIG);
if (r != 0)
{
break;
}
// Claim interface
Console.WriteLine("Set Interface..");
r = MonoUsbApi.ClaimInterface(device_handle, MY_INTERFACE);
if (r != 0)
{
break;
}
/////////////////////
// Write test data //
/////////////////////
int packetCount = 0;
int transferredTotal = 0;
do
{
Console.WriteLine("Sending test data..");
// If the Async TEST_MODE enumeration is set, use
// the internal transfer function
if (TEST_MODE == TestMode.Async)
{
r = (int)doBulkAsyncTransfer(device_handle,
MY_EP_WRITE,
testWriteData,
TEST_WRITE_LEN,
out transferred,
MY_TIMEOUT);
}
else
{
// Use the sync bulk transfer API function
r = MonoUsbApi.BulkTransfer(device_handle,
MY_EP_WRITE,
testWriteData,
TEST_WRITE_LEN,
out transferred,
MY_TIMEOUT);
}
if (r == 0)
{
packetCount++;
transferredTotal += transferred;
}
// Keep writing data until an error occurs or
// 4 packets have been sent.
} while (r == 0 && packetCount < 5);
if (r == (int)MonoUsbError.ErrorTimeout)
{
// This is considered normal operation
Console.WriteLine("Write Timed Out. {0} packet(s) written ({1} bytes)", packetCount, transferredTotal);
}
else if (r != (int)MonoUsbError.ErrorTimeout && r != 0)
{
// An error, other than ErrorTimeout was received.
Console.WriteLine("Write failed:{0}", (MonoUsbError)r);
break;
}
////////////////////
// Read test data //
////////////////////
Console.WriteLine("Reading test data..");
packetCount = 0;
transferredTotal = 0;
do
{
// If the Async TEST_MODE enumeration is set, use
// the internal transfer function
if (TEST_MODE == TestMode.Async)
{
r = (int)doBulkAsyncTransfer(device_handle,
MY_EP_READ,
testReadData,
TEST_READ_LEN,
out transferred,
MY_TIMEOUT);
}
else
{
// Use the sync bulk transfer API function
r = MonoUsbApi.BulkTransfer(device_handle,
MY_EP_READ,
testReadData,
TEST_READ_LEN,
out transferred,
MY_TIMEOUT);
}
if (r == (int)MonoUsbError.ErrorTimeout)
{
// This is considered normal operation
Console.WriteLine("Read Timed Out. {0} packet(s) read ({1} bytes)", packetCount, transferredTotal);
}
else if (r != 0)
{
// An error, other than ErrorTimeout was received.
Console.WriteLine("Read failed:{0}", (MonoUsbError)r);
}
else
{
transferredTotal += transferred;
packetCount++;
// Display test data.
Console.Write("Received: ");
Console.WriteLine(System.Text.Encoding.Default.GetString(testReadData, 0, transferred));
}
// Keep reading data until an error occurs, (ErrorTimeout)
} while (r == 0);
} while (false);
}
finally
{
// Free and close resources
if (device_handle != null)
{
if (!device_handle.IsInvalid)
{
MonoUsbApi.ReleaseInterface(device_handle, MY_INTERFACE);
device_handle.Close();
}
}
if (sessionHandle != null)
{
sessionHandle.Close();
sessionHandle = null;
}
}
// Run the entire test TEST_LOOP_COUNT times.
} while (++loopCount < TEST_LOOP_COUNT);
Console.WriteLine("\nDone! [Press any key to exit]");
Console.ReadKey();
return(r);
}
void testComms()
{
if (profiles.Count < 1)
{
logger.info("testComms: no profiles");
return;
}
foreach (MonoUsbProfile profile in profiles)
{
MonoUsbDeviceHandle device = null;
try
{
logger.info("Opening {0:x4}:{1:x4}", profile.DeviceDescriptor.VendorID, profile.DeviceDescriptor.ProductID);
device = profile.OpenDeviceHandle();
if (device.IsInvalid)
{
logger.error("Failed opening device handle: {0} ({1})", MonoUsbDeviceHandle.LastErrorCode, MonoUsbDeviceHandle.LastErrorString);
continue;
}
// re-confirm configurations for this profile
for (byte i = 0; i < profile.DeviceDescriptor.ConfigurationCount; i++)
{
MonoUsbConfigHandle configHandle;
if (MonoUsbApi.GetConfigDescriptor(profile.ProfileHandle, i, out configHandle) < 0)
{
continue;
}
if (configHandle.IsInvalid)
{
continue;
}
MonoUsbConfigDescriptor configDescriptor = new MonoUsbConfigDescriptor(configHandle);
logger.info(" configuration #{0}: {1} ({2})", i, configDescriptor.bConfigurationValue, configDescriptor);
logger.info(" type = {0}", configDescriptor.bDescriptorType);
logger.info(" length = {0}", configDescriptor.bLength);
logger.info(" attributes = {0:x2}", configDescriptor.bmAttributes);
logger.info(" interfaces = {0}", configDescriptor.bNumInterfaces);
logger.info(" extLength = {0}", configDescriptor.ExtraLength);
logger.info(" iConfig = {0}", configDescriptor.iConfiguration);
logger.info(" maxPower = {0}", configDescriptor.MaxPower);
logger.info(" totalLength= {0}", configDescriptor.wTotalLength);
}
int result = 0;
// Set Configuration
// Note: http://libusb.sourceforge.net/api-1.0/caveats.html#configsel
MonoUsbError error = (MonoUsbError)(result = MonoUsbApi.SetConfiguration(device, 1));
if (false && result < 0)
{
logger.error("Failed SetConfiguration: {0} ({1}) (result = {2})", error, MonoUsbApi.StrError(error), result);
continue;
}
// Claim Interface
error = (MonoUsbError)(result = MonoUsbApi.ClaimInterface(device, 0));
if (result < 0)
{
logger.error("Failed ClaimInterface: {0} ({1})", error, MonoUsbApi.StrError(error));
continue;
}
// retain device handles
devices.Add(device);
byte DEVICE_TO_HOST = 0xc0;
byte SECOND_TIER_COMMAND = 0xff;
byte GET_MODEL_CONFIG = 0x01;
byte PAGE_SIZE = 64;
byte PAGE_ID = 0;
int TIMEOUT_MS = 1000;
// Create a vendor specific control setup, allocate 1 byte for return control data.
// byte requestType = (byte)(UsbCtrlFlags.Direction_In | UsbCtrlFlags.Recipient_Device | UsbCtrlFlags.RequestType_Vendor);
// byte request = 0x0F;
// MonoUsbControlSetupHandle controlSetupHandle = new MonoUsbControlSetupHandle(requestType, request, 0, 0, 1);
MonoUsbControlSetupHandle controlSetupHandle = new MonoUsbControlSetupHandle(DEVICE_TO_HOST, SECOND_TIER_COMMAND, GET_MODEL_CONFIG, PAGE_ID, PAGE_SIZE);
// Transfer the control setup packet
int len = libusb_control_transfer(device, controlSetupHandle, TIMEOUT_MS);
if (len > 0)
{
logger.info("Success");
byte[] ctrlDataBytes = controlSetupHandle.ControlSetup.GetData(len);
string ctrlDataString = Helper.HexString(ctrlDataBytes, String.Empty, "h ");
logger.info("Return Length: {0}", len);
logger.info("DATA (hex) : [ {0} ]", ctrlDataString.Trim());
}
MonoUsbApi.ReleaseInterface(device, 0);
}
finally
{
if (device != null)
{
logger.info("closing device");
device.Close();
}
}
}
}
static void Main(string[] args)
{
MonoUsbSessionHandle sessionHandle = null;
MonoUsbDeviceHandle rapidradio = null;
try
{
if (args.Length == 1 && args[0] == "--help")
{
Usage();
return;
}
var cmdParams = ParseCmdParams(args);
// set up USB lib
sessionHandle = new MonoUsbSessionHandle();
if (sessionHandle.IsInvalid)
{
throw new Exception("Invalid session handle.");
}
MonoUsbProfileListHandle list;
MonoUsbApi.GetDeviceList(sessionHandle, out list);
var profileList = new MonoUsbProfileList();
profileList.Refresh(sessionHandle);
var rapidradios = profileList.Where(d => d.DeviceDescriptor != null && d.DeviceDescriptor.VendorID == Vid && d.DeviceDescriptor.ProductID == Pid).ToArray();
if (rapidradios.Length == 0)
{
Error("rapidradio USB device not found");
}
if (rapidradios.Length > 1)
{
// more than 1 rapidradio USB attached
Error(string.Format("Detected {0} rapidradio USB modules - currently only one device is supported.", rapidradios.Length), false);
}
rapidradio = rapidradios[0].OpenDeviceHandle();
if (rapidradio == null || rapidradio.IsInvalid)
{
throw new Exception("Invalid session handle.");
}
var r = MonoUsbApi.SetConfiguration(rapidradio, 1);
if (r != 0)
{
Error("SetConfiguration error: " + GetErrorMessage(r));
}
r = MonoUsbApi.ClaimInterface(rapidradio, 0);
if (r != 0)
{
Error("ClaimInterface error: " + GetErrorMessage(r));
}
_unmanagedReadBuff = Marshal.AllocHGlobal(32);
_unmanagedWriteBuff = Marshal.AllocHGlobal(32);
// send configuration to endpoint 4
var settings = cmdParams.Serialize();
SendData(rapidradio, 4, settings, settings.Length, 200);
// send custom register settings (if any)
foreach (var regPacket in cmdParams.SerializeRfmRegisters())
{
if (cmdParams.Verbose)
{
Info(string.Format("Setting register R{0}={1}", regPacket[1], regPacket[2]));
}
SendData(rapidradio, 4, regPacket, regPacket.Length);
}
var stopWatch = new Stopwatch();
if (_stats)
{
stopWatch.Start();
}
if (cmdParams.Verbose)
{
Info(string.Format("Address = 0x{0}", cmdParams.Address.ToString("X8")));
Info(string.Format("Channel = {0}", cmdParams.Channel));
Info(string.Format("Mode = {0}", cmdParams.SinglePacket == null ? cmdParams.Mode.ToString() : "Single Packet Mode"));
Info(string.Format("ACK {0}", cmdParams.Ack ? "enabled" : "disabled"));
Info(string.Format("Retries = {0}", cmdParams.Retries));
if (cmdParams.SinglePacket == null)
{
Info(string.Format("Packet Numbering {0}", cmdParams.PacketNumbering ? "enabled" : "disabled"));
}
}
if (cmdParams.SinglePacket != null)
{
// send exactly one packet
StartReadingThread(rapidradio);
SendData(rapidradio, 2, cmdParams.SinglePacket.ToArray(), cmdParams.SinglePacket.Count);
StopReadingThread();
}
else
{
switch (cmdParams.Mode)
{
case RadioMode.Listening:
Listening(rapidradio, cmdParams);
break;
case RadioMode.Sending:
Sending(rapidradio, cmdParams);
break;
default:
throw new ArgumentOutOfRangeException("Unknown mode");
}
}
if (_stats)
{
Info("Transmission took " + stopWatch.Elapsed);
}
// switch off the radio
TurnOff(rapidradio);
}
catch (Exception e)
{
Error("An error occured: " + GetRecursiveMessage(e, 10));
}
finally
{
{
// Free and close resources
if (rapidradio != null)
{
if (!rapidradio.IsInvalid)
{
MonoUsbApi.ReleaseInterface(rapidradio, 0);
rapidradio.Close();
}
}
if (sessionHandle != null)
{
sessionHandle.Close();
}
Marshal.FreeHGlobal(_unmanagedReadBuff);
Marshal.FreeHGlobal(_unmanagedWriteBuff);
}
}
}
private void SendCommand(byte[] data, int duration)
{
MonoUsbProfileList profileList = new MonoUsbProfileList();
MonoUsbDeviceHandle myDeviceHandle = null;
try
{
// The list is initially empty.
// Each time refresh is called the list contents are updated.
profileList.Refresh(sessionHandle);
// Use the GetList() method to get a generic List of MonoUsbProfiles
// Find the first profile that matches in MyVidPidPredicate.
MonoUsbProfile myProfile = profileList.GetList().Find(MyVidPidPredicate);
if (myProfile == null)
{
Console.WriteLine("Device not connected.");
return;
}
Console.WriteLine("Device connected.");
// Open the device handle to perform I/O
myDeviceHandle = myProfile.OpenDeviceHandle();
if (myDeviceHandle.IsInvalid)
{
throw new Exception(String.Format("Failed opening device handle.\n{0}:{1}",
MonoUsbDeviceHandle.LastErrorCode,
MonoUsbDeviceHandle.LastErrorString));
}
int ret;
MonoUsbError e;
// Set Configuration
e = (MonoUsbError)(ret = MonoUsbApi.SetConfiguration(myDeviceHandle, 1));
if (ret < 0)
{
throw new Exception(String.Format("Failed SetConfiguration.\n{0}:{1}", e, MonoUsbApi.StrError(e)));
}
// Claim Interface
e = (MonoUsbError)(ret = MonoUsbApi.ClaimInterface(myDeviceHandle, 0));
if (ret < 0)
{
throw new Exception(String.Format("Failed ClaimInterface.\n{0}:{1}", e, MonoUsbApi.StrError(e)));
}
// Create a vendor specific control setup, allocate 1 byte for return control data.
byte requestType = 0x40;// (byte)(UsbCtrlFlags.Direction_In | UsbCtrlFlags.Recipient_Device | UsbCtrlFlags.RequestType_Vendor);
byte request = 6;
MonoUsbControlSetupHandle controlSetupHandle = new MonoUsbControlSetupHandle(requestType, request, 0x100, 0, data, 3);
// Transfer the control setup packet
ret = ControlTransfer(myDeviceHandle, controlSetupHandle, 1000);
Thread.Sleep(duration);
object data2 = new byte[] { 0, 0, 0 };
MonoUsbControlSetupHandle controlSetupHandle2 = new MonoUsbControlSetupHandle(requestType, request, 0x100, 0, data2, 3);
ret = ControlTransfer(myDeviceHandle, controlSetupHandle2, 1000);
Thread.Sleep(500);
if (ret > 0)
{
Console.WriteLine("\nSuccess!\n");
byte[] ctrlDataBytes = controlSetupHandle.ControlSetup.GetData(ret);
string ctrlDataString = Helper.HexString(ctrlDataBytes, String.Empty, "h ");
Console.WriteLine("Return Length: {0}", ret);
Console.WriteLine("DATA (hex) : [ {0} ]\n", ctrlDataString.Trim());
}
MonoUsbApi.ReleaseInterface(myDeviceHandle, 0);
}
finally
{
profileList.Close();
if (myDeviceHandle != null)
{
myDeviceHandle.Close();
}
sessionHandle.Close();
Console.WriteLine("End");
}
}
private bool SetConfigUsbDevice()
{
int ret;
if (FinalDeviceIndex == -1)
{
throw new Exception("No valid device index exists. Discovery of device wasnot successful.");
}
if (false)
{
try{
MyUsbDevice = MyUsbDeviceArray[FinalDeviceIndex];
if (MyUsbDevice == null)
{
throw new Exception("Device not found");
}
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Select config #1
wholeUsbDevice.SetConfiguration(1);
wholeUsbDevice.ClaimInterface(0);
}
// open read endpoint 1
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
globalReader = reader;
}
catch (Exception ex) {
Console.WriteLine(ex);
}
}
MonoUsbError e;
myDeviceHandle = MatchingUsbDeviceList[FinalDeviceIndex].OpenDeviceHandle();
if (myDeviceHandle == null || myDeviceHandle.IsInvalid)
{
throw new Exception(String.Format("Device not open previously {0}:{1}",
MonoUsbDeviceHandle.LastErrorCode,
MonoUsbDeviceHandle.LastErrorString
));
}
// set configuration
e = (MonoUsbError)(ret = MonoUsbApi.SetConfiguration(myDeviceHandle, 1));
if (ret < 0)
{
throw new Exception(String.Format("Failed SetConfiguration. {0}:{1}", e, MonoUsbApi.StrError(e)));
}
;;;
// cliam interface
e = (MonoUsbError)(ret = MonoUsbApi.ClaimInterface(myDeviceHandle, 0));
if (ret < 0)
{
throw new Exception(String.Format("Failed ClaimInterface. {0}:{1}", e, MonoUsbApi.StrError(e)));
}
;;;
return(true);
}