/// <summary>
/// Stops the handle events thread and closes the session handle.
/// </summary>
public static void Exit()
{
Stop(true);
if (mSessionHandle == null) return;
if (mSessionHandle.IsInvalid) return;
mSessionHandle.Close();
mSessionHandle = null;
}
/// <summary>
/// Convenience function for finding a device with a particular idVendor/idProduct combination.
/// </summary>
/// <remarks>
/// <note type="tip" title="Libusb-1.0 API:"><seelibusb10 group="dev"/></note>
/// </remarks>
/// <param name="sessionHandle">A valid <see cref="MonoUsbSessionHandle"/>.</param>
/// <param name="vendorID">The idVendor value to search for.</param>
/// <param name="productID">The idProduct value to search for.</param>
/// <returns>Null if the device was not opened or not found, otherwise an opened device handle.</returns>
public static MonoUsbDeviceHandle OpenDeviceWithVidPid([In] MonoUsbSessionHandle sessionHandle, short vendorID, short productID)
{
IntPtr pHandle = OpenDeviceWithVidPidInternal(sessionHandle, vendorID, productID);
if (pHandle == IntPtr.Zero)
{
return(null);
}
return(new MonoUsbDeviceHandle(pHandle));
}
private static void HandleEventFn(object oHandle)
{
MonoUsbSessionHandle sessionHandle = oHandle as MonoUsbSessionHandle;
mIsStoppedEvent.Reset();
while (mRunning)
{
MonoUsbApi.HandleEventsTimeout(sessionHandle, ref mWaitUnixNativeTimeval);
}
mIsStoppedEvent.Set();
}
private static void Init(UnixNativeTimeval unixNativeTimeval)
{
if (IsStopped && !mRunning && mSessionHandle == null)
{
mWaitUnixNativeTimeval = unixNativeTimeval;
mSessionHandle = new MonoUsbSessionHandle();
if (mSessionHandle.IsInvalid)
{
mSessionHandle = null;
throw new UsbException(typeof(MonoUsbApi), String.Format("Init:libusb_init Failed:Invalid Session Handle"));
}
}
}
/// <summary>
/// Stops the handle events thread and closes the session handle.
/// </summary>
public static void Exit()
{
Stop(true);
if (mSessionHandle == null)
{
return;
}
if (mSessionHandle.IsInvalid)
{
return;
}
mSessionHandle.Dispose();
mSessionHandle = null;
}
/// <summary>
/// Creates a new ProgrammingConnection; if the Unified Lab Kit can't be found,
/// it throws a DeviceNotConnected excpetion.
/// </summary>
/// <param name="Timeout">
/// The amount of time to wait before the system decides the device isn't connected.
/// </param>
public ProgrammingConnection(short timeout)
{
int retries = 5;
//store the timeout field from the constructor
this.timeout = timeout;
//create a new local USB session
session = new MonoUsbSessionHandle();
while (retries-- > 0)
{
try
{
//find the device by its descriptor
device = MonoUsbApi.OpenDeviceWithVidPid(session, VID, PID);
}
catch (ObjectDisposedException ex)
{
if (retries == 0)
{
//DEBUG
DebugConsole.WriteLine("Windows could not create the USB connection... try again in a few seconds?");
throw ex;
}
//DEBUG
DebugConsole.WriteLine("Too soon! Retrying in 15s.");
System.Threading.Thread.Sleep(15000);
continue;
}
//break on success
break;
}
if (device == null)
throw new DeviceNotFoundException();
//if the kernel has a driver operating on our interface, ask it to detach
if (MonoUsbApi.KernelDriverActive(device, 0) >= 0)
if (MonoUsbApi.DetachKernelDriver(device, 0) < 0)
throw new DeviceInUseException();
//claim our interface for exclusive access
MonoUsbApi.ClaimInterface(device, 0);
}
/// <summary>
/// Creates a new ProgrammingConnection; if the Unified Lab Kit can't be found,
/// it throws a DeviceNotConnected excpetion.
/// </summary>
/// <param name="Timeout">
/// The amount of time to wait before the system decides the device isn't connected.
/// </param>
public MonoProgrammingConnection()
{
//create a new local USB session
session = new MonoUsbSessionHandle();
//find the device by its descriptor
device = MonoUsbApi.OpenDeviceWithVidPid(session, VID, PID);
if(device==null)
throw new DeviceNotFoundException();
//if the kernel has a driver operating on our interface, ask it to detach
if(MonoUsbApi.KernelDriverActive(device, 0) >=0 )
if(MonoUsbApi.DetachKernelDriver(device, 0) < 0)
throw new DeviceInUseException();
//claim our interface for exclusive access
MonoUsbApi.ClaimInterface(device, 0);
}
/// <summary>
/// Retrieve a list of file descriptors that should be polled by your main loop as libusb event sources.
/// </summary>
/// <remarks>
/// <note type="tip" title="Libusb-1.0 API:"><seelibusb10 group="poll"/></note>
/// </remarks>
/// <param name="sessionHandle">A valid <see cref="MonoUsbSessionHandle"/>.</param>
/// <returns>A list of PollfdItem structures, or null on error.</returns>
public static List <PollfdItem> GetPollfds(MonoUsbSessionHandle sessionHandle)
{
List <PollfdItem> rtnList = new List <PollfdItem>();
IntPtr pList = GetPollfdsInternal(sessionHandle);
if (pList == IntPtr.Zero)
{
return(null);
}
IntPtr pNext = pList;
IntPtr pPollfd;
while ((((pNext != IntPtr.Zero))) && (pPollfd = Marshal.ReadIntPtr(pNext)) != IntPtr.Zero)
{
PollfdItem pollfdItem = new PollfdItem(pPollfd);
rtnList.Add(pollfdItem);
pNext = new IntPtr(pNext.ToInt64() + IntPtr.Size);
}
Marshal.FreeHGlobal(pList);
return(rtnList);
}
/// <summary>
/// Perform a USB control transfer for multi-threaded applications using the <see cref="MonoUsbEventHandler"/> class.
/// </summary>
/// <remarks>
/// <para>The direction of the transfer is inferred from the bmRequestType field of the setup packet.</para>
/// <para>The wValue, wIndex and wLength fields values should be given in host-endian byte order.</para>
/// <note type="tip" title="Libusb-1.0 API:"><seelibusb10 group="syncio"/></note>
/// </remarks>
/// <param name="deviceHandle">A handle for the device to communicate with.</param>
/// <param name="requestType">The request type field for the setup packet.</param>
/// <param name="request">The request field for the setup packet.</param>
/// <param name="value">The value field for the setup packet</param>
/// <param name="index">The index field for the setup packet.</param>
/// <param name="pData">A suitably-sized data buffer for either input or output (depending on direction bits within bmRequestType).</param>
/// <param name="dataLength">The length field for the setup packet. The data buffer should be at least this size.</param>
/// <param name="timeout">timeout (in milliseconds) that this function should wait before giving up due to no response being received. For an unlimited timeout, use value 0.</param>
/// <returns>
/// <list type="bullet">
/// <item>on success, the number of bytes actually transferred</item>
/// <item><see cref="MonoUsbError.ErrorTimeout"/> if the transfer timed out</item>
/// <item><see cref="MonoUsbError.ErrorPipe"/> if the control request was not supported by the device.</item>
/// <item><see cref="MonoUsbError.ErrorNoDevice"/> if the device has been disconnected</item>
/// <item>another <see cref="MonoUsbError"/> code on other failures</item>
/// </list>
/// </returns>
public static int ControlTransferAsync([In] MonoUsbDeviceHandle deviceHandle, byte requestType, byte request, short value, short index, IntPtr pData, short dataLength, int timeout)
{
MonoUsbControlSetupHandle setupHandle = new MonoUsbControlSetupHandle(requestType, request, value, index, pData, dataLength);
MonoUsbTransfer transfer = new MonoUsbTransfer(0);
ManualResetEvent completeEvent = new ManualResetEvent(false);
GCHandle gcCompleteEvent = GCHandle.Alloc(completeEvent);
transfer.FillControl(deviceHandle, setupHandle, DefaultAsyncDelegate, GCHandle.ToIntPtr(gcCompleteEvent), timeout);
int r = (int)transfer.Submit();
if (r < 0)
{
transfer.Free();
gcCompleteEvent.Free();
return(r);
}
IntPtr pSessionHandle;
MonoUsbSessionHandle sessionHandle = MonoUsbEventHandler.SessionHandle;
if (sessionHandle == null)
{
pSessionHandle = IntPtr.Zero;
}
else
{
pSessionHandle = sessionHandle.DangerousGetHandle();
}
if (MonoUsbEventHandler.IsStopped)
{
while (!completeEvent.WaitOne(0))
{
r = HandleEvents(pSessionHandle);
if (r < 0)
{
if (r == (int)MonoUsbError.ErrorInterrupted)
{
continue;
}
transfer.Cancel();
while (!completeEvent.WaitOne(0))
{
if (HandleEvents(pSessionHandle) < 0)
{
break;
}
}
transfer.Free();
gcCompleteEvent.Free();
return(r);
}
}
}
else
{
completeEvent.WaitOne(Timeout.Infinite);
}
if (transfer.Status == MonoUsbTansferStatus.TransferCompleted)
{
r = transfer.ActualLength;
if (r > 0)
{
byte[] ctrlDataBytes = setupHandle.ControlSetup.GetData(r);
Marshal.Copy(ctrlDataBytes, 0, pData, Math.Min(ctrlDataBytes.Length, dataLength));
}
}
else
{
r = (int)MonoLibUsbErrorFromTransferStatus(transfer.Status);
}
transfer.Free();
gcCompleteEvent.Free();
return(r);
}
/// <summary>
/// Retrieve a list of file descriptors that should be polled by your main loop as libusb event sources.
/// </summary>
/// <remarks>
/// <note type="tip" title="Libusb-1.0 API:"><seelibusb10 group="poll"/></note>
/// </remarks>
/// <param name="sessionHandle">A valid <see cref="MonoUsbSessionHandle"/>.</param>
/// <returns>A list of PollfdItem structures, or null on error.</returns>
public static List<PollfdItem> GetPollfds(MonoUsbSessionHandle sessionHandle)
{
List<PollfdItem> rtnList = new List<PollfdItem>();
IntPtr pList = GetPollfdsInternal(sessionHandle);
if (pList == IntPtr.Zero) return null;
IntPtr pNext = pList;
IntPtr pPollfd;
while ((((pNext != IntPtr.Zero))) && (pPollfd = Marshal.ReadIntPtr(pNext)) != IntPtr.Zero)
{
PollfdItem pollfdItem = new PollfdItem(pPollfd);
rtnList.Add(pollfdItem);
pNext = new IntPtr(pNext.ToInt64() + IntPtr.Size);
}
Marshal.FreeHGlobal(pList);
return rtnList;
}
private static void Main(string[] args)
{
// 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)
{
Console.WriteLine("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)
{
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();
}
}
public static void Main(string[] args)
{
// Initialize the context.
sessionHandle = new MonoUsbSessionHandle();
if (sessionHandle.IsInvalid)
throw new Exception(String.Format("Failed intialized libusb context.\n{0}:{1}",
MonoUsbSessionHandle.LastErrorCode,
MonoUsbSessionHandle.LastErrorString));
MonoUsbProfileList profileList = new MonoUsbProfileList();
// The list is initially empty.
// Each time refresh is called the list contents are updated.
int ret = profileList.Refresh(sessionHandle);
if (ret < 0) throw new Exception("Failed to retrieve device list.");
Console.WriteLine("{0} device(s) found.", ret);
// Use the GetList() method to get a generic List of MonoUsbProfiles
// Find all profiles that match in the MyVidPidPredicate.
List<MonoUsbProfile> myVidPidList = profileList.GetList().FindAll(MyVidPidPredicate);
// myVidPidList reresents a list of connected USB devices that matched
// in MyVidPidPredicate.
foreach (MonoUsbProfile profile in myVidPidList)
{
// Write the VendorID and ProductID to console output.
Console.WriteLine("[Device] Vid:{0:X4} Pid:{1:X4}", profile.DeviceDescriptor.VendorID, profile.DeviceDescriptor.ProductID);
// Loop through all of the devices configurations.
for (byte i = 0; i < profile.DeviceDescriptor.ConfigurationCount; i++)
{
// Get a handle to the configuration.
MonoUsbConfigHandle configHandle;
if (MonoUsbApi.GetConfigDescriptor(profile.ProfileHandle, i, out configHandle) < 0) continue;
if (configHandle.IsInvalid) continue;
// Create a MonoUsbConfigDescriptor instance for this config handle.
MonoUsbConfigDescriptor configDescriptor = new MonoUsbConfigDescriptor(configHandle);
// Write the bConfigurationValue to console output.
Console.WriteLine(" [Config] bConfigurationValue:{0}", configDescriptor.bConfigurationValue);
// Interate through the InterfaceList
foreach (MonoUsbInterface usbInterface in configDescriptor.InterfaceList)
{
// Interate through the AltInterfaceList
foreach (MonoUsbAltInterfaceDescriptor usbAltInterface in usbInterface.AltInterfaceList)
{
// Write the bInterfaceNumber and bAlternateSetting to console output.
Console.WriteLine(" [Interface] bInterfaceNumber:{0} bAlternateSetting:{1}",
usbAltInterface.bInterfaceNumber,
usbAltInterface.bAlternateSetting);
// Interate through the EndpointList
foreach (MonoUsbEndpointDescriptor endpoint in usbAltInterface.EndpointList)
{
// Write the bEndpointAddress, EndpointType, and wMaxPacketSize to console output.
Console.WriteLine(" [Endpoint] bEndpointAddress:{0:X2} EndpointType:{1} wMaxPacketSize:{2}",
endpoint.bEndpointAddress,
(EndpointType) (endpoint.bmAttributes & 0x3),
endpoint.wMaxPacketSize);
}
}
}
// Not neccessary, but good programming practice.
configHandle.Close();
}
}
// Not neccessary, but good programming practice.
profileList.Close();
// Not neccessary, but good programming practice.
sessionHandle.Close();
}
private static void Init(UnixNativeTimeval unixNativeTimeval)
{
if (IsStopped && !mRunning && mSessionHandle==null)
{
mWaitUnixNativeTimeval = unixNativeTimeval;
mSessionHandle=new MonoUsbSessionHandle();
if (mSessionHandle.IsInvalid)
{
mSessionHandle = null;
throw new UsbException(typeof (MonoUsbApi), String.Format("Init:libusb_init Failed:Invalid Session Handle"));
}
}
}