/// <summary> /// Uses a series of API calls to locate a HID-class device /// by its Vendor ID and Product ID. /// </summary> /// /// <returns> /// True if the device is detected, False if not detected. /// </returns> private Boolean FindTheHid(Int32 myVendorID, Int32 myProductID) { Boolean deviceFound = false; String[] devicePathName = new String[128]; String functionName = ""; Guid hidGuid = Guid.Empty; Int32 memberIndex = 0; Boolean success = false; try { myDeviceDetected = false; Tracer.Trace(string.Format("FindTheHid(0x{0:X04}, 0x{1:X04})", myVendorID, myProductID)); // *** // API function: 'HidD_GetHidGuid // Purpose: Retrieves the interface class GUID for the HID class. // Accepts: 'A System.Guid object for storing the GUID. // *** Hid.HidD_GetHidGuid(ref hidGuid); functionName = "GetHidGuid"; Tracer.Trace(MyDebugging.ResultOfAPICall(functionName)); Tracer.Trace(" GUID for system HIDs: " + hidGuid.ToString()); // Fill an array with the device path names of all attached HIDs. deviceFound = MyDeviceManagement.FindDeviceFromGuid(hidGuid, ref devicePathName); // If there is at least one HID, attempt to read the Vendor ID and Product ID // of each device until there is a match or all devices have been examined. if (deviceFound) { memberIndex = 0; do { // *** // API function: // CreateFile // Purpose: // Retrieves a handle to a device. // Accepts: // A device path name returned by SetupDiGetDeviceInterfaceDetail // The type of access requested (read/write). // FILE_SHARE attributes to allow other processes to access the device while this handle is open. // A Security structure or IntPtr.Zero. // A creation disposition value. Use OPEN_EXISTING for devices. // Flags and attributes for files. Not used for devices. // Handle to a template file. Not used. // Returns: a handle without read or write access. // This enables obtaining information about all HIDs, even system // keyboards and mice. // Separate handles are used for reading and writing. // *** hidHandle = FileIO.CreateFile(devicePathName[memberIndex], 0, FileIO.FILE_SHARE_READ | FileIO.FILE_SHARE_WRITE, IntPtr.Zero, FileIO.OPEN_EXISTING, 0, 0); functionName = "CreateFile"; Tracer.Trace(MyDebugging.ResultOfAPICall(functionName)); Tracer.Trace(" Returned handle: " + hidHandle.ToString()); if (!hidHandle.IsInvalid) { // The returned handle is valid, // so find out if this is the device we're looking for. // Set the Size property of DeviceAttributes to the number of bytes in the structure. MyHid.DeviceAttributes.Size = Marshal.SizeOf(MyHid.DeviceAttributes); // *** // API function: // HidD_GetAttributes // Purpose: // Retrieves a HIDD_ATTRIBUTES structure containing the Vendor ID, // Product ID, and Product Version Number for a device. // Accepts: // A handle returned by CreateFile. // A pointer to receive a HIDD_ATTRIBUTES structure. // Returns: // True on success, False on failure. // *** success = Hid.HidD_GetAttributes(hidHandle, ref MyHid.DeviceAttributes); if (success) { Tracer.Trace(" HIDD_ATTRIBUTES structure filled without error."); Tracer.Trace(" Structure size: " + MyHid.DeviceAttributes.Size); Tracer.Trace(" Vendor ID: " + Convert.ToString(MyHid.DeviceAttributes.VendorID, 16)); Tracer.Trace(" Product ID: " + Convert.ToString(MyHid.DeviceAttributes.ProductID, 16)); Tracer.Trace(" Version Number: " + Convert.ToString(MyHid.DeviceAttributes.VersionNumber, 16)); // Find out if the device matches the one we're looking for. if ((MyHid.DeviceAttributes.VendorID == myVendorID) && (MyHid.DeviceAttributes.ProductID == myProductID)) { Tracer.Trace(" My device detected"); // Display the information in form's list box. Tracer.Trace("Device detected:"); Tracer.Trace(" Vendor ID= " + Convert.ToString(MyHid.DeviceAttributes.VendorID, 16)); Tracer.Trace(" Product ID = " + Convert.ToString(MyHid.DeviceAttributes.ProductID, 16)); myDeviceDetected = true; // Save the DevicePathName for OnDeviceChange(). myDevicePathName = devicePathName[memberIndex]; } else { // It's not a match, so close the handle. myDeviceDetected = false; hidHandle.Close(); } } else { // There was a problem in retrieving the information. Tracer.Trace(" Error in filling HIDD_ATTRIBUTES structure."); myDeviceDetected = false; hidHandle.Close(); } } // Keep looking until we find the device or there are no devices left to examine. memberIndex = memberIndex + 1; } while (!((myDeviceDetected || (memberIndex == devicePathName.Length)))); } if (myDeviceDetected) { // The device was detected. // Register to receive notifications if the device is removed or attached. success = MyDeviceManagement.RegisterForDeviceNotifications(myDevicePathName, m_mainForm.Handle, hidGuid, ref deviceNotificationHandle); Tracer.Trace("RegisterForDeviceNotifications = " + success); // Learn the capabilities of the device. MyHid.Capabilities = MyHid.GetDeviceCapabilities(hidHandle); if (success) { // Find out if the device is a system mouse or keyboard. hidUsage = MyHid.GetHidUsage(MyHid.Capabilities); // Get the Input report buffer size. GetInputReportBufferSize(); // Get handles to use in requesting Input and Output reports. readHandle = FileIO.CreateFile(myDevicePathName, FileIO.GENERIC_READ, FileIO.FILE_SHARE_READ | FileIO.FILE_SHARE_WRITE, IntPtr.Zero, FileIO.OPEN_EXISTING, FileIO.FILE_FLAG_OVERLAPPED, 0); functionName = "CreateFile, ReadHandle"; Tracer.Trace(MyDebugging.ResultOfAPICall(functionName)); Tracer.Trace(" Returned handle: " + readHandle.ToString()); if (readHandle.IsInvalid) { exclusiveAccess = true; Tracer.Error("The device is a system " + hidUsage + ". Applications can access Feature reports only."); } else { writeHandle = FileIO.CreateFile(myDevicePathName, FileIO.GENERIC_WRITE, FileIO.FILE_SHARE_READ | FileIO.FILE_SHARE_WRITE, IntPtr.Zero, FileIO.OPEN_EXISTING, 0, 0); functionName = "CreateFile, WriteHandle"; Tracer.Trace(MyDebugging.ResultOfAPICall(functionName)); Tracer.Trace(" Returned handle: " + writeHandle.ToString()); // Flush any waiting reports in the input buffer. (optional) MyHid.FlushQueue(readHandle); } } } else { // The device wasn't detected. Tracer.Error("Device not found."); } return myDeviceDetected; } catch (Exception ex) { Tracer.Error(ex); throw; } }
internal static void SafeCloseHandle(SafeFileHandle handle) { if (handle != null && !handle.IsInvalid) handle.Close(); }
/// <summary> /// closes open handles to a device. /// </summary> /// /// <param name="hidHandle"> the handle for learning about the device and exchanging Feature reports. </param> /// <param name="readHandle"> the handle for reading Input reports from the device. </param> /// <param name="writeHandle"> the handle for writing Output reports to the device. </param> internal void CancelTransfer(SafeFileHandle hidHandle, SafeFileHandle readHandle, SafeFileHandle writeHandle, IntPtr eventObject) { try { // *** // API function: CancelIo // Purpose: Cancels a call to ReadFile // Accepts: the device handle. // Returns: True on success, False on failure. // *** FileIO.CancelIo(readHandle); Debug.WriteLine( "************ReadFile error*************" ); String functionName = "CancelIo"; Debug.WriteLine(MyDebugging.ResultOfAPICall(functionName)); Debug.WriteLine( "" ); // The failure may have been because the device was removed, // so close any open handles and // set myDeviceDetected=False to cause the application to // look for the device on the next attempt. if ( ( !( hidHandle.IsInvalid ) ) ) { hidHandle.Close(); } if ( ( !( readHandle.IsInvalid ) ) ) { readHandle.Close(); } if ( ( !( writeHandle.IsInvalid ) ) ) { writeHandle.Close(); } } catch ( Exception ex ) { DisplayException( MODULE_NAME, ex ); throw ; } }
/// <summary> /// writes an Output report to the device. /// </summary> /// /// <param name="outputReportBuffer"> contains the report ID and report data. </param> /// <param name="writeHandle"> handle to the device. </param> /// /// <returns> /// True on success. False on failure. /// </returns> internal override Boolean Write( Byte[] outputReportBuffer, SafeFileHandle writeHandle ) { Int32 numberOfBytesWritten = 0; Boolean success = false; try { // The host will use an interrupt transfer if the the HID has an interrupt OUT // endpoint (requires USB 1.1 or later) AND the OS is NOT Windows 98 Gold (original version). // Otherwise the the host will use a control transfer. // The application doesn't have to know or care which type of transfer is used. numberOfBytesWritten = 0; // *** // API function: WriteFile // Purpose: writes an Output report to the device. // Accepts: // A handle returned by CreateFile // An integer to hold the number of bytes written. // Returns: True on success, False on failure. // *** success = FileIO.WriteFile(writeHandle, outputReportBuffer, outputReportBuffer.Length, ref numberOfBytesWritten, IntPtr.Zero); Debug.Print( "WriteFile success = " + success ); if ( !( ( success ) ) ) { if ( ( !( writeHandle.IsInvalid ) ) ) { writeHandle.Close(); } } return success; } catch ( Exception ex ) { DisplayException( MODULE_NAME, ex ); throw ; } }
private void CleanupHandle(SafeFileHandle handle) { if (handle != null && !handle.IsClosed) { InteropKernel32.CloseHandle(handle); handle.Close(); } }
/// <summary> /// closes open handles to a device. /// </summary> /// /// <param name="hidHandle"> the handle for learning about the device and exchanging Feature reports. </param> /// <param name="readHandle"> the handle for reading Input reports from the device. </param> /// <param name="writeHandle"> the handle for writing Output reports to the device. </param> private void CancelTransfer(SafeFileHandle hidHandle, SafeFileHandle readHandle, SafeFileHandle writeHandle) { // *** // API function: CancelIo // Purpose: Cancels a call to ReadFile // Accepts: the device handle. // Returns: True on success, False on failure. // *** NativeMethods.CancelIo(readHandle); // The failure may have been because the device was removed, // so close any open handles and // set myDeviceDetected=False to cause the application to // look for the device on the next attempt. if ( ( !( hidHandle.IsInvalid ) ) ) { hidHandle.Close(); } if ( ( !( readHandle.IsInvalid ) ) ) { readHandle.Close(); } if ( ( !( writeHandle.IsInvalid ) ) ) { writeHandle.Close(); } }
//-------------------------------------------------------END CUT AND PASTE BLOCK------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------BEGIN CUT AND PASTE BLOCK----------------------------------------------------------------------------------- //This is a callback function that gets called when a Windows message is received by the form. //We will receive various different types of messages, but the ones we really want to use are the WM_DEVICECHANGE messages. protected override void WndProc(ref Message m) { if (m.Msg == WM_DEVICECHANGE) { if (((int)m.WParam == DBT_DEVICEARRIVAL) || ((int)m.WParam == DBT_DEVICEREMOVEPENDING) || ((int)m.WParam == DBT_DEVICEREMOVECOMPLETE) || ((int)m.WParam == DBT_CONFIGCHANGED)) { //WM_DEVICECHANGE messages by themselves are quite generic, and can be caused by a number of different //sources, not just your USB hardware device. Therefore, must check to find out if any changes relavant //to your device (with known VID/PID) took place before doing any kind of opening or closing of handles/endpoints. //(the message could have been totally unrelated to your application/USB device) if (CheckIfPresentAndGetUSBDevicePath()) //Check and make sure at least one device with matching VID/PID is attached { //If executes to here, this means the device is currently attached and was found. //This code needs to decide however what to do, based on whether or not the device was previously known to be //attached or not. if ((AttachedState == false) || (AttachedButBroken == true)) //Check the previous attachment state { uint ErrorStatusWrite; uint ErrorStatusRead; //We obtained the proper device path (from CheckIfPresentAndGetUSBDevicePath() function call), and it //is now possible to open read and write handles to the device. WriteHandleToUSBDevice = CreateFile(DevicePath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero); ErrorStatusWrite = (uint)Marshal.GetLastWin32Error(); ReadHandleToUSBDevice = CreateFile(DevicePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero); ErrorStatusRead = (uint)Marshal.GetLastWin32Error(); if ((ErrorStatusWrite == ERROR_SUCCESS) && (ErrorStatusRead == ERROR_SUCCESS)) { AttachedState = true; //Let the rest of the PC application know the USB device is connected, and it is safe to read/write to it AttachedButBroken = false; StatusBox_txtbx.Text = "Device Found, AttachedState = TRUE"; } else //for some reason the device was physically plugged in, but one or both of the read/write handles didn't open successfully... { AttachedState = false; //Let the rest of this application known not to read/write to the device. AttachedButBroken = true; //Flag so that next time a WM_DEVICECHANGE message occurs, can retry to re-open read/write pipes if (ErrorStatusWrite == ERROR_SUCCESS) WriteHandleToUSBDevice.Close(); if (ErrorStatusRead == ERROR_SUCCESS) ReadHandleToUSBDevice.Close(); } } //else we did find the device, but AttachedState was already true. In this case, don't do anything to the read/write handles, //since the WM_DEVICECHANGE message presumably wasn't caused by our USB device. } else //Device must not be connected (or not programmed with correct firmware) { if (AttachedState == true) //If it is currently set to true, that means the device was just now disconnected { AttachedState = false; WriteHandleToUSBDevice.Close(); ReadHandleToUSBDevice.Close(); } AttachedState = false; AttachedButBroken = false; } } } //end of: if(m.Msg == WM_DEVICECHANGE) base.WndProc(ref m); }
//--------------- End of Global Varibles ------------------ //-------------------------------------------------------END CUT AND PASTE BLOCK------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------------------------------------------------------------------------------------- //Need to check "Allow unsafe code" checkbox in build properties to use unsafe keyword. Unsafe is needed to //properly interact with the unmanged C++ style APIs used to find and connect with the USB device. public unsafe Form1() { InitializeComponent(); //------------------------------------------------------------------------------------------------------------------------------------------------------------------- //-------------------------------------------------------BEGIN CUT AND PASTE BLOCK----------------------------------------------------------------------------------- //Additional constructor code //Initialize tool tips, to provide pop up help when the mouse cursor is moved over objects on the form. ANxVoltageToolTip.SetToolTip(this.ANxVoltage_lbl, "If using a board/PIM without a potentiometer, apply an adjustable voltage to the I/O pin."); ANxVoltageToolTip.SetToolTip(this.progressBar1, "If using a board/PIM without a potentiometer, apply an adjustable voltage to the I/O pin."); ToggleLEDToolTip.SetToolTip(this.ToggleLEDs_btn, "Sends a packet of data to the USB device."); PushbuttonStateTooltip.SetToolTip(this.PushbuttonState_lbl, "Try pressing pushbuttons on the USB demo board/PIM."); //Register for WM_DEVICECHANGE notifications. This code uses these messages to detect plug and play connection/disconnection events for USB devices DEV_BROADCAST_DEVICEINTERFACE DeviceBroadcastHeader = new DEV_BROADCAST_DEVICEINTERFACE(); DeviceBroadcastHeader.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE; DeviceBroadcastHeader.dbcc_size = (uint)Marshal.SizeOf(DeviceBroadcastHeader); DeviceBroadcastHeader.dbcc_reserved = 0; //Reserved says not to use... DeviceBroadcastHeader.dbcc_classguid = InterfaceClassGuid; //Need to get the address of the DeviceBroadcastHeader to call RegisterDeviceNotification(), but //can't use "&DeviceBroadcastHeader". Instead, using a roundabout means to get the address by //making a duplicate copy using Marshal.StructureToPtr(). IntPtr pDeviceBroadcastHeader = IntPtr.Zero; //Make a pointer. pDeviceBroadcastHeader = Marshal.AllocHGlobal(Marshal.SizeOf(DeviceBroadcastHeader)); //allocate memory for a new DEV_BROADCAST_DEVICEINTERFACE structure, and return the address Marshal.StructureToPtr(DeviceBroadcastHeader, pDeviceBroadcastHeader, false); //Copies the DeviceBroadcastHeader structure into the memory already allocated at DeviceBroadcastHeaderWithPointer RegisterDeviceNotification(this.Handle, pDeviceBroadcastHeader, DEVICE_NOTIFY_WINDOW_HANDLE); //Now make an initial attempt to find the USB device, if it was already connected to the PC and enumerated prior to launching the application. //If it is connected and present, we should open read and write handles to the device so we can communicate with it later. //If it was not connected, we will have to wait until the user plugs the device in, and the WM_DEVICECHANGE callback function can process //the message and again search for the device. if(CheckIfPresentAndGetUSBDevicePath()) //Check and make sure at least one device with matching VID/PID is attached { uint ErrorStatusWrite; uint ErrorStatusRead; //We now have the proper device path, and we can finally open read and write handles to the device. WriteHandleToUSBDevice = CreateFile(DevicePath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero); ErrorStatusWrite = (uint)Marshal.GetLastWin32Error(); ReadHandleToUSBDevice = CreateFile(DevicePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero); ErrorStatusRead = (uint)Marshal.GetLastWin32Error(); if((ErrorStatusWrite == ERROR_SUCCESS) && (ErrorStatusRead == ERROR_SUCCESS)) { AttachedState = true; //Let the rest of the PC application know the USB device is connected, and it is safe to read/write to it AttachedButBroken = false; StatusBox_txtbx.Text = "Device Found, AttachedState = TRUE"; } else //for some reason the device was physically plugged in, but one or both of the read/write handles didn't open successfully... { AttachedState = false; //Let the rest of this application known not to read/write to the device. AttachedButBroken = true; //Flag so that next time a WM_DEVICECHANGE message occurs, can retry to re-open read/write pipes if(ErrorStatusWrite == ERROR_SUCCESS) WriteHandleToUSBDevice.Close(); if(ErrorStatusRead == ERROR_SUCCESS) ReadHandleToUSBDevice.Close(); } } else //Device must not be connected (or not programmed with correct firmware) { AttachedState = false; AttachedButBroken = false; } if (AttachedState == true) { StatusBox_txtbx.Text = "Device Found, AttachedState = TRUE"; } else { StatusBox_txtbx.Text = "Device not found, verify connect/correct firmware"; } ReadWriteThread.RunWorkerAsync(); //Recommend performing USB read/write operations in a separate thread. Otherwise, //the Read/Write operations are effectively blocking functions and can lock up the //user interface if the I/O operations take a long time to complete. //-------------------------------------------------------END CUT AND PASTE BLOCK------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------------------------------------------------------------------------------------- }
public String[] FindTheHids() { Boolean deviceFound = false; String[] devicePathName = new String[128]; String functionName = ""; Guid hidGuid = Guid.Empty; Int32 memberIndex = 0; Int16 myProductID = 0; Int16 myVendorID = 0; //Int32 product = 0; //Int32 vendor = 0; Boolean success = false; try { myDeviceDetected = false; //TODO: WTF is going on with this formatting? //vendor = 0xAFEF; //product = 0x0F01; myVendorID = -20497; myProductID = 3841; // *** // API function: 'HidD_GetHidGuid // Purpose: Retrieves the interface class GUID for the HID class. // Accepts: 'A System.Guid object for storing the GUID. // *** Hid.HidD_GetHidGuid(ref hidGuid); functionName = "GetHidGuid"; Debug.WriteLine(MyDebugging.ResultOfAPICall(functionName)); //Console.Out.WriteLine(MyDebugging.ResultOfAPICall(functionName)); Debug.WriteLine(" GUID for system HIDs: " + hidGuid.ToString()); //Console.Out.WriteLine(" GUID for system HIDs: " + hidGuid.ToString()); // Fill an array with the device path names of all attached HIDs. deviceFound = MyDeviceManagement.FindDeviceFromGuid(hidGuid, ref devicePathName); for (int p = 0; p < devicePathName.Length; p++) { Console.Out.WriteLine(devicePathName[p]); } if (deviceFound) { for (int m = 0; m < devicePathName.Length; m++) { hidHandle = FileIO.CreateFile(devicePathName[memberIndex], 0, FileIO.FILE_SHARE_READ | FileIO.FILE_SHARE_WRITE, IntPtr.Zero, FileIO.OPEN_EXISTING, 0, 0); functionName = "CreateFile"; Debug.WriteLine(MyDebugging.ResultOfAPICall(functionName)); if (!hidHandle.IsInvalid) { MyHid.DeviceAttributes.Size = Marshal.SizeOf(MyHid.DeviceAttributes); success = Hid.HidD_GetAttributes(hidHandle, ref MyHid.DeviceAttributes); if (success) { if ((MyHid.DeviceAttributes.VendorID == myVendorID) & (MyHid.DeviceAttributes.ProductID == myProductID)) { Debug.WriteLine(" My device detected"); //Console.Out.WriteLine(" My device detected"); myDeviceDetected = true; // Save the DevicePathName for OnDeviceChange(). myDevicePathName = devicePathName[memberIndex]; } else { // It's not a match, so close the handle. myDeviceDetected = false; hidHandle.Close(); } } else { // There was a problem in retrieving the information. Debug.WriteLine(" Error in filling HIDD_ATTRIBUTES structure."); //Console.Out.WriteLine(" Error in filling HIDD_ATTRIBUTES structure."); myDeviceDetected = false; hidHandle.Close(); } } } if (myDeviceDetected) { MyHid.Capabilities = MyHid.GetDeviceCapabilities(hidHandle); if (success) { // Find out if the device is a system mouse or keyboard. hidUsage = MyHid.GetHidUsage(MyHid.Capabilities); // Get the Input report buffer size. //GetInputReportBufferSize(); //cmdInputReportBufferSize.Enabled = true; // Get handles to use in requesting Input and Output reports. readHandle = FileIO.CreateFile(myDevicePathName, FileIO.GENERIC_READ, FileIO.FILE_SHARE_READ | FileIO.FILE_SHARE_WRITE, IntPtr.Zero, FileIO.OPEN_EXISTING, FileIO.FILE_FLAG_OVERLAPPED, 0); functionName = "CreateFile, ReadHandle"; Debug.WriteLine(MyDebugging.ResultOfAPICall(functionName)); //Console.Out.WriteLine(MyDebugging.ResultOfAPICall(functionName)); Debug.WriteLine(" Returned handle: " + readHandle.ToString()); //Console.Out.WriteLine(" Returned handle: " + readHandle.ToString()); if (readHandle.IsInvalid) { exclusiveAccess = true; //lstResults.Items.Add("The device is a system " + hidUsage + "."); //lstResults.Items.Add("Windows 2000 and Windows XP obtain exclusive access to Input and Output reports for this devices."); //lstResults.Items.Add("Applications can access Feature reports only."); //ScrollToBottomOfListBox(); } else { writeHandle = FileIO.CreateFile(myDevicePathName, FileIO.GENERIC_WRITE, FileIO.FILE_SHARE_READ | FileIO.FILE_SHARE_WRITE, IntPtr.Zero, FileIO.OPEN_EXISTING, 0, 0); functionName = "CreateFile, WriteHandle"; Debug.WriteLine(MyDebugging.ResultOfAPICall(functionName)); //Console.Out.WriteLine(MyDebugging.ResultOfAPICall(functionName)); Debug.WriteLine(" Returned handle: " + writeHandle.ToString()); //Console.Out.WriteLine(" Returned handle: " + writeHandle.ToString()); // Flush any waiting reports in the input buffer. (optional) MyHid.FlushQueue(readHandle); } } else { // The device wasn't detected. //lstResults.Items.Add("Device not found."); //cmdInputReportBufferSize.Enabled = false; //cmdOnce.Enabled = true; Debug.WriteLine(" Device not found."); //Console.Out.WriteLine(" Device not found."); //ScrollToBottomOfListBox(); } //return myDeviceDetected; } } return devicePathName; } catch (Exception ex) { Console.Out.WriteLine(ex.ToString()); throw; } }
public String[] GetGuids() { Boolean deviceFound = false; String[] devicePathName = new String[128]; Queue<string> queueDevicePathName = new Queue<string>(); String functionName = ""; String devpath; Guid hidGuid = Guid.Empty; Int32 memberIndex = 0; Int16 myVendorID = -20497; Int16 myProductID = 3841; Boolean success = false; Hid.HidD_GetHidGuid(ref hidGuid); deviceFound = MyDeviceManagement.FindDeviceFromGuid(hidGuid, ref devicePathName); for (int p = 0; p < devicePathName.Length; p++) { Console.Out.WriteLine(devicePathName[p]); } if (deviceFound) { for (int m = 0; m < devicePathName.Length; m++) { hidHandle = FileIO.CreateFile(devicePathName[m], 0, FileIO.FILE_SHARE_READ | FileIO.FILE_SHARE_WRITE, IntPtr.Zero, FileIO.OPEN_EXISTING, 0, 0); functionName = "CreateFile"; Debug.WriteLine(MyDebugging.ResultOfAPICall(functionName)); if (!hidHandle.IsInvalid) { MyHid.DeviceAttributes.Size = Marshal.SizeOf(MyHid.DeviceAttributes); success = Hid.HidD_GetAttributes(hidHandle, ref MyHid.DeviceAttributes); if (success) { if ((MyHid.DeviceAttributes.VendorID == myVendorID) & (MyHid.DeviceAttributes.ProductID == myProductID)) { Debug.WriteLine(" My device detected"); //Console.Out.WriteLine(" My device detected"); myDeviceDetected = true; // Save the DevicePathName for OnDeviceChange(). //myDevicePathName = devicePathName[memberIndex]; devpath = devicePathName[m]; hidHandle.Close(); queueDevicePathName.Enqueue(devpath); } else { // It's not a match, so close the handle. myDeviceDetected = false; hidHandle.Close(); } } else { // There was a problem in retrieving the information. Debug.WriteLine(" Error in filling HIDD_ATTRIBUTES structure."); //Console.Out.WriteLine(" Error in filling HIDD_ATTRIBUTES structure."); myDeviceDetected = false; hidHandle.Close(); } } } } return queueDevicePathName.ToArray(); }
private static void _CloseHandle(SafeFileHandle h) { try { if (h != null) { h.Close(); h.Dispose(); } } catch { //Eat... } }