public static void Main(string[] args)
{
Error ec = Error.Success;
using (UsbContext context = new UsbContext())
{
try
{
UsbInterfaceInfo usbInterfaceInfo = null;
UsbEndpointInfo usbEndpointInfo = null;
// Find and open the usb device.
using (var regList = context.FindAll(MyUsbFinder))
{
if (regList.Count == 0)
{
throw new Exception("Device Not Found.");
}
// Look through all conected devices with this vid and pid until
// one is found that has and and endpoint that matches TRANFER_ENDPOINT.
//
foreach (var regDevice in regList)
{
if (regDevice.TryOpen())
{
if (regDevice.Configs.Count > 0)
{
// if TRANFER_ENDPOINT is 0x80 or 0x00, LookupEndpointInfo will return the
// first read or write (respectively).
if (UsbEndpointBase.LookupEndpointInfo(MyUsbDevice.Configs[0], TRANFER_ENDPOINT,
out usbInterfaceInfo, out usbEndpointInfo))
{
MyUsbDevice = regDevice.Clone();
MyUsbDevice.Open();
break;
}
regDevice.Close();
}
}
}
}
// If the device is open and ready
if (MyUsbDevice == null)
{
throw new Exception("Device Not Found.");
}
// 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))
{
// 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(usbInterfaceInfo.Number);
}
// open read endpoint.
var reader = MyUsbDevice.OpenEndpointReader(
(ReadEndpointID)usbEndpointInfo.EndpointAddress,
0,
(EndpointType)(usbEndpointInfo.Attributes & 0x3));
if (ReferenceEquals(reader, null))
{
throw new Exception("Failed locating read endpoint.");
}
reader.Reset();
// The benchmark device firmware works with this example but it must be put into PC read mode.
#if IS_BENCHMARK_DEVICE
int transferred;
byte[] ctrlData = new byte[1];
UsbSetupPacket setTestTypePacket =
new UsbSetupPacket((byte)(UsbCtrlFlags.Direction_In | UsbCtrlFlags.Recipient_Device | UsbCtrlFlags.RequestType_Vendor),
0x0E, 0x01, usbInterfaceInfo.Number, 1);
transferred = MyUsbDevice.ControlTransfer(setTestTypePacket, ctrlData, 0, 1);
#endif
TRANFER_SIZE -= (TRANFER_SIZE % usbEndpointInfo.MaxPacketSize);
UsbTransferQueue transferQeue = new UsbTransferQueue(reader,
TRANFER_MAX_OUTSTANDING_IO,
TRANFER_SIZE,
5000,
usbEndpointInfo.MaxPacketSize);
do
{
UsbTransferQueue.Handle handle;
// Begin submitting transfers until TRANFER_MAX_OUTSTANDING_IO has benn reached.
// then wait for the oldest outstanding transfer to complete.
//
ec = transferQeue.Transfer(out handle);
if (ec != Error.Success)
{
throw new Exception("Failed getting async result");
}
// Show some information on the completed transfer.
showTransfer(handle, mTransferCount);
} while (mTransferCount++ < TRANSFER_COUNT);
// Cancels any oustanding transfers and free's the transfer queue handles.
// NOTE: A transfer queue can be reused after it's freed.
transferQeue.Free();
Console.WriteLine("\r\nDone!\r\n");
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine((ec != Error.Success ? ec + ":" : String.Empty) + ex.Message);
}
finally
{
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);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
}
// Wait for user input..
Console.ReadKey();
}
}
}
private void PollUSBDevice()
{
ErrorCode ec = ErrorCode.None;
UsbDevice MyUsbDevice = null;
UsbDeviceFinder MyUsbFinder = new UsbDeviceFinder(multimeter.VendorId, multimeter.ProductId);
UsbEndpointReader reader = null;
try
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
UsbEndpointInfo endpointInfo = null;
UsbInterfaceInfo usbInterfaceInfo = null;
if (UsbEndpointBase.LookupEndpointInfo(MyUsbDevice.Configs[0], UsbConstants.ENDPOINT_DIR_MASK, out usbInterfaceInfo, out endpointInfo) == false)
{
MyUsbDevice.Close();
MyUsbDevice = null;
}
if (MyUsbDevice == null)
{
Application.Current.Dispatcher.BeginInvoke(
new WriteConsolasDelegate(multimeter.WriteConsolas),
new object[] { "Can't find multimeter device!", "Error" });
}
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
wholeUsbDevice.SetConfiguration(1);
wholeUsbDevice.SetConfiguration(0);
wholeUsbDevice.SetConfiguration(1);
wholeUsbDevice.ClaimInterface(usbInterfaceInfo.Descriptor.InterfaceID);
}
UsbSetupPacket packetSettings = new UsbSetupPacket(0x21, 0x09, 0x0300, 0x0000, 0x0005);
byte[] buffer = { 0x60, 0x09, 0x00, 0x00, 0x03 };
int transferred = 0;
MyUsbDevice.ControlTransfer(ref packetSettings, buffer, 5, out transferred);
transferred = 0;
MyUsbDevice.ControlTransfer(ref packetSettings, buffer, 5, out transferred);
try
{
reader = MyUsbDevice.OpenEndpointReader((ReadEndpointID)endpointInfo.Descriptor.EndpointID, 0, (EndpointType)(endpointInfo.Descriptor.Attributes & 0x3));
}
catch (Exception e)
{
Application.Current.Dispatcher.BeginInvoke(
new WriteConsolasDelegate(multimeter.WriteConsolas),
new object[] { e.Message, "Error" });
}
Application.Current.Dispatcher.BeginInvoke(
new WriteConsolasDelegate(multimeter.WriteConsolas),
new object[] { String.Format("Starting read from device <{0}:{1}>.", multimeter.VendorId.ToString(), multimeter.ProductId.ToString()), "Log" });
while (ec == ErrorCode.None && !stopRequested)
{
if (fixRequested)
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
CloseFix();
}));
transferred = 0;
MyUsbDevice.ControlTransfer(ref packetSettings, buffer, 5, out transferred);
transferred = 0;
MyUsbDevice.ControlTransfer(ref packetSettings, buffer, 5, out transferred);
transferred = 0;
MyUsbDevice.ControlTransfer(ref packetSettings, buffer, 5, out transferred);
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
multimeter.WriteConsolas("Fix attempt ended.");
}));
}
byte[] readBuffer = new byte[8];
int bytesRead;
ec = reader.Read(readBuffer, 100, out bytesRead);
byte[] cloneBuffer = readBuffer;
Application.Current.Dispatcher.BeginInvoke(
new OneArgDelegate(HandleData),
new object[] { cloneBuffer });
}
}
catch (Exception ex)
{
try
{
Application.Current.Dispatcher.BeginInvoke(
new WriteConsolasDelegate(multimeter.WriteConsolas),
new object[] { ex.Message, "Error" });
}
catch (Exception e)
{
}
}
finally
{
Application.Current.Dispatcher.BeginInvoke(
new WriteConsolasDelegate(multimeter.WriteConsolas),
new object[] { "Stopping read. " + ec.ToString(), "Log" });
if (reader != null)
{
reader.Abort();
}
if (MyUsbDevice != null)
{
if (MyUsbDevice.IsOpen)
{
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
try
{
UsbDevice.Exit();
}
catch (Exception e)
{
Application.Current.Dispatcher.BeginInvoke(
new WriteConsolasDelegate(multimeter.WriteConsolas),
new object[] { e.Message, "Error" });
}
}
}
}
private bool openAsTestDevice(UsbRegistry usbRegistry)
{
if (!ReferenceEquals(mUsbDevice, null))
{
closeTestDevice(mUsbDevice);
}
mUsbDevice = null;
try
{
if (usbRegistry.Open(out mUsbDevice))
{
UsbInterfaceInfo readInterfaceInfo;
UsbInterfaceInfo writeInterfaceInfo;
UsbDevice.UsbErrorEvent += OnUsbError;
if (!UsbEndpointBase.LookupEndpointInfo(mUsbDevice.Configs[0],
0x80,
out readInterfaceInfo,
out mReadEndpointInfo))
{
throw new Exception("failed locating read endpoint.");
}
mBenchMarkParameters.BufferSize -= (mBenchMarkParameters.BufferSize % (mReadEndpointInfo.Descriptor.MaxPacketSize));
if (!UsbEndpointBase.LookupEndpointInfo(mUsbDevice.Configs[0],
0x00,
out writeInterfaceInfo,
out mWriteEndpointInfo))
{
throw new Exception("failed locating write endpoint.");
}
if (((mWriteEndpointInfo.Descriptor.Attributes & 3) == (int)EndpointType.Isochronous) ||
((mReadEndpointInfo.Descriptor.Attributes & 3) == (int)EndpointType.Isochronous))
{
throw new Exception("buenchmark GUI application does not support ISO endpoints. Use BenchmarkCon instead.");
}
mBenchMarkParameters.BufferSize -= (mBenchMarkParameters.BufferSize % (mWriteEndpointInfo.Descriptor.MaxPacketSize));
if (writeInterfaceInfo.Descriptor.InterfaceID != readInterfaceInfo.Descriptor.InterfaceID)
{
throw new Exception("read/write endpoints must be on the same interface.");
}
mEP1Reader = mUsbDevice.OpenEndpointReader(
(ReadEndpointID)mReadEndpointInfo.Descriptor.EndpointID,
mBenchMarkParameters.BufferSize,
(EndpointType)(mReadEndpointInfo.Descriptor.Attributes & 3));
mEP1Writer = mUsbDevice.OpenEndpointWriter(
(WriteEndpointID)mWriteEndpointInfo.Descriptor.EndpointID,
(EndpointType)(mWriteEndpointInfo.Descriptor.Attributes & 3));
mInterfaceInfo = writeInterfaceInfo;
mEP1Reader.ReadThreadPriority = mBenchMarkParameters.Priority;
mEP1Reader.DataReceived += OnDataReceived;
makeTestBytes(out loopTestBytes, mBenchMarkParameters.BufferSize);
// 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 = mUsbDevice 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(mInterfaceInfo.Descriptor.InterfaceID);
}
return(true);
}
}
catch (Exception ex)
{
SetStatus(ex.Message, true);
}
if (!ReferenceEquals(mUsbDevice, null))
{
try
{
closeTestDevice(mUsbDevice);
}
finally
{
mUsbDevice = null;
mEP1Reader = null;
mEP1Writer = null;
}
}
return(false);
}
public void readIso()
{
ErrorCode ec = ErrorCode.None;
try
{
// Find and open the usb device.
UsbRegDeviceList regList = UsbDevice.AllDevices.FindAll(MyUsbFinder);
if (regList.Count == 0)
{
throw new Exception("Device Not Found.");
}
UsbInterfaceInfo usbInterfaceInfo = null;
UsbEndpointInfo usbEndpointInfo = null;
// Look through all conected devices with this vid and pid until
// one is found that has and and endpoint that matches TRANFER_ENDPOINT.
//
foreach (UsbRegistry regDevice in regList)
{
if (regDevice.Open(out MyUsbDevice))
{
if (MyUsbDevice.Configs.Count > 0)
{
// if TRANFER_ENDPOINT is 0x80 or 0x00, LookupEndpointInfo will return the
// first read or write (respectively).
if (UsbEndpointBase.LookupEndpointInfo(MyUsbDevice.Configs[0], TRANFER_ENDPOINT,
out usbInterfaceInfo, out usbEndpointInfo))
{
break;
}
MyUsbDevice.Close();
MyUsbDevice = null;
}
}
}
// If the device is open and ready
if (MyUsbDevice == null)
{
throw new Exception("Device Not Found.");
}
// 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))
{
// 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(usbInterfaceInfo.Descriptor.InterfaceID);
}
// open read endpoint.
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(
(ReadEndpointID)usbEndpointInfo.Descriptor.EndpointID,
0,
(EndpointType)(usbEndpointInfo.Descriptor.Attributes & 0x3));
if (ReferenceEquals(reader, null))
{
throw new Exception("Failed locating read endpoint.");
}
reader.Reset();
TRANFER_SIZE -= (TRANFER_SIZE % usbEndpointInfo.Descriptor.MaxPacketSize);
UsbTransferQueue transferQeue = new UsbTransferQueue(reader,
TRANFER_MAX_OUTSTANDING_IO,
TRANFER_SIZE,
5000,
usbEndpointInfo.Descriptor.MaxPacketSize);
do
{
UsbTransferQueue.Handle handle;
// Begin submitting transfers until TRANFER_MAX_OUTSTANDING_IO has benn reached.
// then wait for the oldest outstanding transfer to complete.
//
ec = transferQeue.Transfer(out handle);
if (ec != ErrorCode.Success)
{
throw new Exception("Failed getting async result");
}
// Show some information on the completed transfer.
showTransfer(handle, mTransferCount);
} while (mTransferCount++ < TRANSFER_COUNT);
// Cancels any oustanding transfers and free's the transfer queue handles.
// NOTE: A transfer queue can be reused after it's freed.
transferQeue.Free();
}
catch (Exception ex)
{
form.setText("\r\n");
form.setText((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
}
finally
{
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);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
}
// Free usb resources
UsbDevice.Exit();
}
}
/// <summary>
/// Get Endpoint reader
/// </summary>
/// <returns></returns>
private static UsbEndpointReader GetReader(out UsbDevice MyUsbDevice, out int interfaceID)
{
UsbDeviceFinder MyUsbFinder = new UsbDeviceFinder(0x1915, 0x7B);
// Find and open the usb device.
UsbRegDeviceList regList = UsbDevice.AllDevices.FindAll(MyUsbFinder);
if (regList.Count == 0)
{
throw new Exception("No receiver devices found.\r\n");
}
UsbInterfaceInfo usbInterfaceInfo = null;
UsbEndpointInfo usbEndpointInfo = null;
MyUsbDevice = null;
// Look through all conected devices with this vid and pid until
// one is found that has and and endpoint that matches TRANFER_ENDPOINT.
//
foreach (UsbRegistry regDevice in regList)
{
if (regDevice.Open(out MyUsbDevice))
{
if (MyUsbDevice.Configs.Count > 0)
{
// if TRANFER_ENDPOINT is 0x80 or 0x00, LookupEndpointInfo will return the
// first read or write (respectively).
if (UsbEndpointBase.LookupEndpointInfo(MyUsbDevice.Configs[0], 0x88,//TRANSFER_ENDPOINT,
out usbInterfaceInfo, out usbEndpointInfo))
{
break;
}
MyUsbDevice.Close();
MyUsbDevice = null;
}
}
}
// If the device is open and ready
if (MyUsbDevice == null)
{
throw new Exception("Receiver device was found, but did not have the correct endpoint address.\r\n");
}
// 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))
{
// 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);
wholeUsbDevice.ClaimInterface(usbInterfaceInfo.Descriptor.InterfaceID);
}
else
{
throw new Exception("Could not find Penny receiver device");
}
interfaceID = usbInterfaceInfo.Descriptor.InterfaceID;
// open read endpoint.
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(
(ReadEndpointID)usbEndpointInfo.Descriptor.EndpointID,
0,
(EndpointType)(usbEndpointInfo.Descriptor.Attributes & 0x3));
if (ReferenceEquals(reader, null))
{
throw new Exception("Failed to locate read endpoint for JAGA Penny receiver.\r\n");
}
reader.Reset();
return(reader);
}