Travailler avec des périphériques USB dans .NET
https://stackoverflow.com/questions/68749
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Avec .Net (C #), comment travailler avec des périphériques USB?
Comment détecter les événements USB (connexions / déconnexions) et comment communiquer avec les périphériques (lecture / écriture).
Existe-t-il une solution .Net native pour le faire?
La solution
Il n’existe pas de solution native (par exemple, les bibliothèques système) pour cela. C’est la raison pour laquelle SharpUSBLib existe comme indiqué par moobaa .
Si vous souhaitez lancer votre propre gestionnaire pour les périphériques USB, vous pouvez consulter le Classe SerialPort de System.IO.Ports .
Autres conseils
J'ai essayé d'utiliser SharpUSBLib et cela a bousillé mon ordinateur (une restauration du système était nécessaire). Est arrivé à un collègue sur le même projet aussi.
J'ai trouvé une alternative dans LibUSBDotNet: http://sourceforge.net/projects/libusbdotnet . Je ne l'ai pas encore beaucoup utilisé, mais il semble bon et récemment mis à jour (contrairement à Sharp).
EDIT: À la mi-février 2017, LibUSBDotNet était mis à jour il y a environ 2 semaines. SharpUSBLib n’a pas été mis à jour depuis 2004.
J'ai utilisé le code suivant pour détecter le moment où les périphériques USB étaient branchés et débranchés de mon ordinateur:
class USBControl : IDisposable
{
// used for monitoring plugging and unplugging of USB devices.
private ManagementEventWatcher watcherAttach;
private ManagementEventWatcher watcherRemove;
public USBControl()
{
// Add USB plugged event watching
watcherAttach = new ManagementEventWatcher();
//var queryAttach = new WqlEventQuery("SELECT * FROM Win32_DeviceChangeEvent WHERE EventType = 2");
watcherAttach.EventArrived += new EventArrivedEventHandler(watcher_EventArrived);
watcherAttach.Query = new WqlEventQuery("SELECT * FROM Win32_DeviceChangeEvent WHERE EventType = 2");
watcherAttach.Start();
// Add USB unplugged event watching
watcherRemove = new ManagementEventWatcher();
//var queryRemove = new WqlEventQuery("SELECT * FROM Win32_DeviceChangeEvent WHERE EventType = 3");
watcherRemove.EventArrived += new EventArrivedEventHandler(watcher_EventRemoved);
watcherRemove.Query = new WqlEventQuery("SELECT * FROM Win32_DeviceChangeEvent WHERE EventType = 3");
watcherRemove.Start();
}
/// <summary>
/// Used to dispose of the USB device watchers when the USBControl class is disposed of.
/// </summary>
public void Dispose()
{
watcherAttach.Stop();
watcherRemove.Stop();
//Thread.Sleep(1000);
watcherAttach.Dispose();
watcherRemove.Dispose();
//Thread.Sleep(1000);
}
void watcher_EventArrived(object sender, EventArrivedEventArgs e)
{
Debug.WriteLine("watcher_EventArrived");
}
void watcher_EventRemoved(object sender, EventArrivedEventArgs e)
{
Debug.WriteLine("watcher_EventRemoved");
}
~USBControl()
{
this.Dispose();
}
}
Vous devez vous assurer que vous appelez la méthode Dispose () lors de la fermeture de votre application. Sinon, vous recevrez une erreur d'objet COM au moment de l'exécution lors de la fermeture.
Je recommanderais LibUSBDotNet , la bibliothèque que j'utilise depuis 2 ans. Si vous devez travailler avec un périphérique USB (demandes d’envoi, réponses de processus), cette bibliothèque est la meilleure solution que je puisse trouver.
Avantages:
- Toutes les méthodes dont vous avez besoin pour travailler en mode synchronisé ou asynchrone.
- Code source fourni
- Assez d'échantillons pour commencer à l'utiliser immédiatement.
Inconvénients:
- Documentation médiocre (problème courant dans les projets open source). En gros, vous pouvez trouver une description commune des méthodes dans le fichier d’aide de CHM et c’est tout. Mais je trouve toujours des exemples fournis et le code source suffit pour le codage. Parfois, je vois un comportement étrange et je veux savoir pourquoi il a été mis en œuvre de cette façon et je ne peux même pas avoir un indice ...
- semble ne plus être supporté. La dernière version a été publiée en octobre 2010. Et il est parfois difficile d'obtenir des réponses.
Vous trouverez un tutoriel sur comment utiliser la bibliothèque SharpUSBLib et les pilotes HID avec C # ici:
http://www.developerfusion.com/article/84338 / faire-usb-c-friendly /
Il existe une boîte à outils générique WinDriver pour écrire des pilotes USB en mode utilisateur qui supporte également .NET
Si vous possédez un logiciel National Instruments sur votre PC, vous pouvez créer un pilote USB à l'aide de leur "Assistant de pilote NI-VISA" .
Procédure de création du pilote USB: http://www.ni.com/tutorial / 4478 / fr /
Une fois le pilote créé, vous pourrez écrire et lire des octets sur n’importe quel périphérique USB.
Assurez-vous que le pilote est visible par Windows dans le Gestionnaire de périphériques:
Code C #:
using NationalInstruments.VisaNS;
#region UsbRaw
/// <summary>
/// Class to communicate with USB Devices using the UsbRaw Class of National Instruments
/// </summary>
public class UsbRaw
{
private NationalInstruments.VisaNS.UsbRaw usbRaw;
private List<byte> DataReceived = new List<byte>();
/// <summary>
/// Initialize the USB Device to interact with
/// </summary>
/// <param name="ResourseName">In this format: "USB0::0x1448::0x8CA0::NI-VISA-30004::RAW". Use the NI-VISA Driver Wizard from Start»All Programs»National Instruments»VISA»Driver Wizard to create the USB Driver for the device you need to talk to.</param>
public UsbRaw(string ResourseName)
{
usbRaw = new NationalInstruments.VisaNS.UsbRaw(ResourseName, AccessModes.NoLock, 10000, false);
usbRaw.UsbInterrupt += new UsbRawInterruptEventHandler(OnUSBInterrupt);
usbRaw.EnableEvent(UsbRawEventType.UsbInterrupt, EventMechanism.Handler);
}
/// <summary>
/// Clears a USB Device from any previous commands
/// </summary>
public void Clear()
{
usbRaw.Clear();
}
/// <summary>
/// Writes Bytes to the USB Device
/// </summary>
/// <param name="EndPoint">USB Bulk Out Pipe attribute to send the data to. For example: If you see on the Bus Hound sniffer tool that data is coming out from something like 28.4 (Device column), this means that the USB is using Endpoint 4 (Number after the dot)</param>
/// <param name="BytesToSend">Data to send to the USB device</param>
public void Write(short EndPoint, byte[] BytesToSend)
{
usbRaw.BulkOutPipe = EndPoint;
usbRaw.Write(BytesToSend); // Write to USB
}
/// <summary>
/// Reads bytes from a USB Device
/// </summary>
/// <returns>Bytes Read</returns>
public byte[] Read()
{
usbRaw.ReadByteArray(); // This fires the UsbRawInterruptEventHandler
byte[] rxBytes = DataReceived.ToArray(); // Collects the data received
return rxBytes;
}
/// <summary>
/// This is used to get the data received by the USB device
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnUSBInterrupt(object sender, UsbRawInterruptEventArgs e)
{
try
{
DataReceived.Clear(); // Clear previous data received
DataReceived.AddRange(e.DataBuffer);
}
catch (Exception exp)
{
string errorMsg = "Error: " + exp.Message;
DataReceived.AddRange(ASCIIEncoding.ASCII.GetBytes(errorMsg));
}
}
/// <summary>
/// Use this function to clean up the UsbRaw class
/// </summary>
public void Dispose()
{
usbRaw.DisableEvent(UsbRawEventType.UsbInterrupt, EventMechanism.Handler);
if (usbRaw != null)
{
usbRaw.Dispose();
}
}
}
#endregion UsbRaw
Utilisation:
UsbRaw usbRaw = new UsbRaw("USB0::0x1448::0x8CA0::NI-VISA-30004::RAW");
byte[] sendData = new byte[] { 0x53, 0x4c, 0x56 };
usbRaw.Write(4, sendData); // Write bytes to the USB Device
byte[] readData = usbRaw.Read(); // Read bytes from the USB Device
usbRaw.Dispose();
J'espère que cela aide quelqu'un.
Les périphériques USB appartiennent généralement à deux catégories: Hid et USB. Un périphérique USB peut être ou non un périphérique caché et inversement. Caché est généralement un peu plus facile à utiliser que l’USB direct. Différentes plates-formes ont des API différentes pour traiter à la fois USB et Hid.
Voici la documentation pour UWP:
Caché: https://docs.microsoft.com/en-us/ uwp / api / windows.devices.humaninterfacedevice
Voici la documentation pour Android: https://developer.xamarin.com/api/namespace/Android.Hardware .Usb /
Voici deux classes permettant de traiter avec USB / Hid au niveau des API Windows brutes:
public static class HidAPICalls
{
#region Constants
private const int DigcfDeviceinterface = 16;
private const int DigcfPresent = 2;
private const uint FileShareRead = 1;
private const uint FileShareWrite = 2;
private const uint GenericRead = 2147483648;
private const uint GenericWrite = 1073741824;
private const uint OpenExisting = 3;
private const int HIDP_STATUS_SUCCESS = 0x110000;
private const int HIDP_STATUS_INVALID_PREPARSED_DATA = -0x3FEF0000;
#endregion
#region API Calls
[DllImport("hid.dll", SetLastError = true)]
private static extern bool HidD_GetPreparsedData(SafeFileHandle hidDeviceObject, out IntPtr pointerToPreparsedData);
[DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
private static extern bool HidD_GetManufacturerString(SafeFileHandle hidDeviceObject, IntPtr pointerToBuffer, uint bufferLength);
[DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
private static extern bool HidD_GetProductString(SafeFileHandle hidDeviceObject, IntPtr pointerToBuffer, uint bufferLength);
[DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
private static extern bool HidD_GetSerialNumberString(SafeFileHandle hidDeviceObject, IntPtr pointerToBuffer, uint bufferLength);
[DllImport("hid.dll", SetLastError = true)]
private static extern int HidP_GetCaps(IntPtr pointerToPreparsedData, out HidCollectionCapabilities hidCollectionCapabilities);
[DllImport("hid.dll", SetLastError = true)]
private static extern bool HidD_GetAttributes(SafeFileHandle hidDeviceObject, out HidAttributes attributes);
[DllImport("hid.dll", SetLastError = true)]
private static extern bool HidD_FreePreparsedData(ref IntPtr pointerToPreparsedData);
[DllImport("hid.dll", SetLastError = true)]
private static extern void HidD_GetHidGuid(ref Guid hidGuid);
private delegate bool GetString(SafeFileHandle hidDeviceObject, IntPtr pointerToBuffer, uint bufferLength);
#endregion
#region Helper Methods
#region Public Methods
public static HidAttributes GetHidAttributes(SafeFileHandle safeFileHandle)
{
var isSuccess = HidD_GetAttributes(safeFileHandle, out var hidAttributes);
WindowsDeviceBase.HandleError(isSuccess, "Could not get Hid Attributes");
return hidAttributes;
}
public static HidCollectionCapabilities GetHidCapabilities(SafeFileHandle readSafeFileHandle)
{
var isSuccess = HidD_GetPreparsedData(readSafeFileHandle, out var pointerToPreParsedData);
WindowsDeviceBase.HandleError(isSuccess, "Could not get pre parsed data");
var result = HidP_GetCaps(pointerToPreParsedData, out var hidCollectionCapabilities);
if (result != HIDP_STATUS_SUCCESS)
{
throw new Exception(public static partial class WinUsbApiCalls
{
#region Constants
public const int EnglishLanguageID = 1033;
public const uint DEVICE_SPEED = 1;
public const byte USB_ENDPOINT_DIRECTION_MASK = 0X80;
public const int WritePipeId = 0x80;
/// <summary>
/// Not sure where this constant is defined...
/// </summary>
public const int DEFAULT_DESCRIPTOR_TYPE = 0x01;
public const int USB_STRING_DESCRIPTOR_TYPE = 0x03;
#endregion
#region API Calls
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_ControlTransfer(IntPtr InterfaceHandle, WINUSB_SETUP_PACKET SetupPacket, byte[] Buffer, uint BufferLength, ref uint LengthTransferred, IntPtr Overlapped);
[DllImport("winusb.dll", SetLastError = true, CharSet = CharSet.Auto)]
public static extern bool WinUsb_GetAssociatedInterface(SafeFileHandle InterfaceHandle, byte AssociatedInterfaceIndex, out SafeFileHandle AssociatedInterfaceHandle);
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_GetDescriptor(SafeFileHandle InterfaceHandle, byte DescriptorType, byte Index, ushort LanguageID, out USB_DEVICE_DESCRIPTOR deviceDesc, uint BufferLength, out uint LengthTransfered);
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_GetDescriptor(SafeFileHandle InterfaceHandle, byte DescriptorType, byte Index, UInt16 LanguageID, byte[] Buffer, UInt32 BufferLength, out UInt32 LengthTransfered);
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_Free(SafeFileHandle InterfaceHandle);
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_Initialize(SafeFileHandle DeviceHandle, out SafeFileHandle InterfaceHandle);
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_QueryDeviceInformation(IntPtr InterfaceHandle, uint InformationType, ref uint BufferLength, ref byte Buffer);
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_QueryInterfaceSettings(SafeFileHandle InterfaceHandle, byte AlternateInterfaceNumber, out USB_INTERFACE_DESCRIPTOR UsbAltInterfaceDescriptor);
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_QueryPipe(SafeFileHandle InterfaceHandle, byte AlternateInterfaceNumber, byte PipeIndex, out WINUSB_PIPE_INFORMATION PipeInformation);
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_ReadPipe(SafeFileHandle InterfaceHandle, byte PipeID, byte[] Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped);
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_SetPipePolicy(IntPtr InterfaceHandle, byte PipeID, uint PolicyType, uint ValueLength, ref uint Value);
[DllImport("winusb.dll", SetLastError = true)]
public static extern bool WinUsb_WritePipe(SafeFileHandle InterfaceHandle, byte PipeID, byte[] Buffer, uint BufferLength, out uint LengthTransferred, IntPtr Overlapped);
#endregion
#region Public Methods
public static string GetDescriptor(SafeFileHandle defaultInterfaceHandle, byte index, string errorMessage)
{
var buffer = new byte[256];
var isSuccess = WinUsb_GetDescriptor(defaultInterfaceHandle, USB_STRING_DESCRIPTOR_TYPE, index, EnglishLanguageID, buffer, (uint)buffer.Length, out var transfered);
WindowsDeviceBase.HandleError(isSuccess, errorMessage);
var descriptor = new string(Encoding.Unicode.GetChars(buffer, 2, (int)transfered));
return descriptor.Substring(0, descriptor.Length - 1);
}
#endregion
}
quot;Could not get Hid capabilities. Return code: {result}");
}
isSuccess = HidD_FreePreparsedData(ref pointerToPreParsedData);
WindowsDeviceBase.HandleError(isSuccess, "Could not release handle for getting Hid capabilities");
return hidCollectionCapabilities;
}
public static string GetManufacturer(SafeFileHandle safeFileHandle)
{
return GetHidString(safeFileHandle, HidD_GetManufacturerString);
}
public static string GetProduct(SafeFileHandle safeFileHandle)
{
return GetHidString(safeFileHandle, HidD_GetProductString);
}
public static string GetSerialNumber(SafeFileHandle safeFileHandle)
{
return GetHidString(safeFileHandle, HidD_GetSerialNumberString);
}
#endregion
#region Private Static Methods
private static string GetHidString(SafeFileHandle safeFileHandle, GetString getString)
{
var pointerToBuffer = Marshal.AllocHGlobal(126);
var isSuccess = getString(safeFileHandle, pointerToBuffer, 126);
Marshal.FreeHGlobal(pointerToBuffer);
WindowsDeviceBase.HandleError(isSuccess, "Could not get Hid string");
return Marshal.PtrToStringUni(pointerToBuffer);
}
#endregion
#endregion
}
internal class TrezorExample : IDisposable
{
#region Fields
//Define the types of devices to search for. This particular device can be connected to via USB, or Hid
private readonly List<FilterDeviceDefinition> _DeviceDefinitions = new List<FilterDeviceDefinition>
{
new FilterDeviceDefinition{ DeviceType= DeviceType.Hid, VendorId= 0x534C, ProductId=0x0001, Label="Trezor One Firmware 1.6.x", UsagePage=65280 },
new FilterDeviceDefinition{ DeviceType= DeviceType.Usb, VendorId= 0x534C, ProductId=0x0001, Label="Trezor One Firmware 1.6.x (Android Only)" },
new FilterDeviceDefinition{ DeviceType= DeviceType.Usb, VendorId= 0x1209, ProductId=0x53C1, Label="Trezor One Firmware 1.7.x" },
new FilterDeviceDefinition{ DeviceType= DeviceType.Usb, VendorId= 0x1209, ProductId=0x53C0, Label="Model T" }
};
#endregion
#region Events
public event EventHandler TrezorInitialized;
public event EventHandler TrezorDisconnected;
#endregion
#region Public Properties
public IDevice TrezorDevice { get; private set; }
public DeviceListener DeviceListener { get; private set; }
#endregion
#region Event Handlers
private void DevicePoller_DeviceInitialized(object sender, DeviceEventArgs e)
{
TrezorDevice = e.Device;
TrezorInitialized?.Invoke(this, new EventArgs());
}
private void DevicePoller_DeviceDisconnected(object sender, DeviceEventArgs e)
{
TrezorDevice = null;
TrezorDisconnected?.Invoke(this, new EventArgs());
}
#endregion
#region Public Methods
public void StartListening()
{
TrezorDevice?.Dispose();
DeviceListener = new DeviceListener(_DeviceDefinitions, 3000);
DeviceListener.DeviceDisconnected += DevicePoller_DeviceDisconnected;
DeviceListener.DeviceInitialized += DevicePoller_DeviceInitialized;
}
public async Task InitializeTrezorAsync()
{
//Get the first available device and connect to it
var devices = await DeviceManager.Current.GetDevices(_DeviceDefinitions);
TrezorDevice = devices.FirstOrDefault();
await TrezorDevice.InitializeAsync();
}
public async Task<byte[]> WriteAndReadFromDeviceAsync()
{
//Create a buffer with 3 bytes (initialize)
var writeBuffer = new byte[64];
writeBuffer[0] = 0x3f;
writeBuffer[1] = 0x23;
writeBuffer[2] = 0x23;
//Write the data to the device
return await TrezorDevice.WriteAndReadAsync(writeBuffer);
}
public void Dispose()
{
TrezorDevice?.Dispose();
}
#endregion
}
Avec l'une de ces solutions, vous devrez soit interroger le périphérique à un intervalle, soit utiliser l'une des classes d'écoute de périphérique natives de l'API. Toutefois, cette bibliothèque place une couche sur Hid et une clé USB sur toutes les plates-formes afin que vous puissiez détecter facilement les connexions et déconnexions: https://github.com/MelbourneDeveloper/Device.Net/wiki/Device-Listener . Voici comment vous l'utiliseriez:
<*>La plupart des chipsets USB sont livrés avec des pilotes. Silicon Labs en possède un.
J'ai une interface avec un Teensy qui fonctionne assez bien avec cet article
J'ai essayé plusieurs de ces suggestions sans succès. J'ai fini par écrire une solution de travail utilisant Java et la bibliothèque hid4java . En tant qu'application de console, je peux y accéder à partir de C # en utilisant Process.Start () , en transmettant des paramètres et en lisant les réponses. Ceci fournit des E / S HID de base mais sans événement de connexion / déconnexion. Pour cela, je devrais le réécrire pour qu'il s'exécute en tant que démon / service et utilise des canaux nommés ou un autre type de transport serveur / client. Pour le moment, il suffit de faire le travail puisque la bibliothèque hi4java "ne fonctionne que".
