private bool OpenCustomDevice(out WinUsbDevice usb, out UsbEndpointReader reader, out UsbEndpointWriter writer)
{
usb = null;
reader = null;
writer = null;
var device = UsbDevice.AllWinUsbDevices.FirstOrDefault(d => d.Vid == 0x1974 && d.Pid == 0x0001) as WinUsbRegistry;
if (device != null)
{
if (device.Open(out usb))
{
writer = usb.OpenEndpointWriter(WriteEndpointID.Ep01);
writer.Reset();
writer.Flush();
reader = usb.OpenEndpointReader(ReadEndpointID.Ep01);
reader.Reset();
reader.Flush();
reader.ReadBufferSize = 32;
reader.DataReceived += CustomDataReceived;
reader.DataReceivedEnabled = true;
return(true);
}
}
return(false);
}
private static void InitalizeAndVerify()
{
bool Success = false;
while (Success == false)
{
Writer = DI_2008.OpenEndpointWriter(WriteEndpointID.Ep01);
Reader = DI_2008.OpenEndpointReader(ReadEndpointID.Ep01);
//No clue what these do but they keep the device from hanging on program restarts #TrialAndError
Writer.Abort();
Writer.Reset();
Writer.Flush();
Reader.Abort();
Reader.ReadFlush();
Reader.Flush();
Reader.Reset();
InternalFunctions.Write("stop"); //Make sure the device wasnt left in a scan state
try
{
var DeviceResponding = InternalFunctions.Write("info 0");
Success = DeviceResponding.Contains("DATAQ");
}
catch { }
}
}
/// <summary>
/// Disposes any unmanaged resources.
/// <remarks>Greatly inspired by the examples in the LibUsbDotNet documentation.</remarks>
/// </summary>
public void Dispose()
{
UsbEndpointReader.Flush();
UsbEndpointReader.Reset();
UsbEndpointReader.Dispose();
UsbEndpointWriter.Flush();
UsbEndpointWriter.Reset();
UsbEndpointWriter.Dispose();
if (UsbDevice == null)
{
return;
}
if (UsbDevice.IsOpen)
{
var wholeUsbDevice = UsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
Shouter.ShoutLine(4, "Interface released.");
}
UsbDevice.Close();
Shouter.ShoutLine(4, "Device closed.");
}
UsbDevice = null;
// Free usb resources
UsbDevice.Exit();
Shouter.ShoutLine(4, "USB resources freed.");
}
private bool OpenDevice()
{
if (_controlWrite == null)
{
var device = UsbDevice.AllWinUsbDevices.FirstOrDefault(d =>
{
var dev = d as WinUsbRegistry;
return(dev.Vid == 0x054C && dev.Pid == 0x09AF && dev.InterfaceID == 5);
}) as WinUsbRegistry;
if (device != null)
{
WinUsbDevice _usb;
if (device.Open(out _usb))
{
PostActions.Clear();
_controlRead = _usb.OpenEndpointReader(ReadEndpointID.Ep04);
_controlRead.Reset();
_controlRead.Flush();
_controlRead.ReadBufferSize = 64;
_controlRead.DataReceived += ControlRead;
_controlRead.DataReceivedEnabled = true;
_controlWrite = _usb.OpenEndpointWriter(WriteEndpointID.Ep04);
_controlWrite.Reset();
_controlWrite.Flush();
//ActivateDisplay(true, () =>
//{
// LedControl(true, () =>
// {
// EnableTracking(true, () =>
// {
// SetVRMode(true);
// });
// });
//});
}
}
}
if (_sensorRead == null)
{
var device = UsbDevice.AllWinUsbDevices.FirstOrDefault(d =>
{
var dev = d as WinUsbRegistry;
return(dev.Vid == 0x054C && dev.Pid == 0x09AF && dev.InterfaceID == 4);
}) as WinUsbRegistry;
if (device != null)
{
WinUsbDevice _usb;
if (device.Open(out _usb))
{
_sensorRead = _usb.OpenEndpointReader(ReadEndpointID.Ep03);
_sensorRead.Reset();
_sensorRead.Flush();
_sensorRead.ReadBufferSize = 64;
_sensorRead.DataReceived += SensorRead;
_sensorRead.DataReceivedEnabled = true;
}
}
}
return(_sensorRead != null && _controlWrite != null);
}
public static string WriteAndRead(int vid, int pid, byte[] byteArrayWritten)
{
ErrorCode ec = ErrorCode.None;
UsbDevice MyUsbDevice = null;
UsbDeviceFinder MyUsbFinder = new UsbDeviceFinder(vid, pid);
try
{
// Find and open the usb device.
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
// If the device is open and ready
if (MyUsbDevice == null)
{
throw new Exception("Device Not Found. vid=" + vid + ", pid=" + pid);
}
// If this is a "whole" usb device (libusb-win32, linux libusb)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// This is a "whole" USB device. Before it can be used,
// the desired configuration and interface must be selected.
// Select config #1
wholeUsbDevice.SetConfiguration(1);
// Claim interface #0.
wholeUsbDevice.ClaimInterface(0);
}
// open read endpoint 1.
using (UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep02))
{
reader.Reset();
// open write endpoint 1.
using (UsbEndpointWriter writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01))
{
UsbTransfer usbTransfer = null;
try
{
writer.Reset();
// Remove the exepath/startup filename text from the begining of the CommandLine.
if (byteArrayWritten.Length > 0)
{
int bytesWritten;
ec = writer.Write(byteArrayWritten, 2000, out bytesWritten);
if (ec != ErrorCode.None)
{
throw new Exception(UsbDevice.LastErrorString);
}
byte[] readBuffer = new byte[256];
string retString = "";
while (ec == ErrorCode.None)
{
Thread.Sleep(1000);
int bytesRead;
// If the device hasn't sent data in the last 100 milliseconds,
// a timeout error (ec = IoTimedOut) will occur.
ec = reader.Read(readBuffer, 1000, out bytesRead);
if (ec != ErrorCode.None)
{
throw new Exception(UsbDevice.LastErrorString);
}
if (bytesRead == 0)
{
return(retString);
//throw new Exception("No more bytes!");
}
// Write that output to the console.
//Console.Write(Encoding.Default.GetString(readBuffer, 0, bytesRead));
retString += Encoding.Default.GetString(readBuffer, 0, bytesRead);
}
//Console.WriteLine("\r\nDone!\r\n");
}
else
{
throw new Exception("Nothing to do.");
}
}
finally
{
if (usbTransfer != null)
{
// **** Start of code added to fix ObjectDisposedException
if (!usbTransfer.IsCancelled || !usbTransfer.IsCompleted)
{
usbTransfer.Cancel();
}
// **** End of code added to fix ObjectDisposedException
usbTransfer.Dispose();
}
}
}
}
}
catch (Exception ex)
{
throw new RMSAppException("WriteAndRead failed. " + ex.Message, ex, true);
//Console.WriteLine();
//Console.WriteLine((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
}
finally
{
try
{
if (MyUsbDevice != null)
{
if (MyUsbDevice.IsOpen)
{
// If this is a "whole" usb device (libusb-win32, linux libusb-1.0)
// it exposes an IUsbDevice interface. If not (WinUSB) the
// 'wholeUsbDevice' variable will be null indicating this is
// an interface of a device; it does not require or support
// configuration and interface selection.
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
//wholeUsbDevice.ResetDevice();
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
// Free usb resources
UsbDevice.Exit();
}
System.Threading.Thread.Sleep(750);
}
catch (Exception ex)
{
new RMSAppException("WriteAndReadUSB - Closing USB failed. " + ex.Message, ex, true);
}
}
return(null);
}
