Utilisation de périphériques USB dans .NET

Question

Avec .Net (C#), comment travailler avec des périphériques USB?

Comment pouvez-vous détecter les événements USB (connexions/déconnexions) et comment communiquez-vous avec les périphériques (lecture/écriture)?

Existe-t-il une solution native .Net pour cela?

Answer 1

Il n'existe aucune solution native (par exemple, bibliothèques système) pour cela. C'est la raison pour laquelle SharpUSBLib existe comme mentionné par moobaa.

Si vous souhaitez faire rouler votre propre gestionnaire pour les périphériques USB, vous pouvez consulter le SerialPort class of System.IO.Ports.

Answer 2

The #usblib USB Library for .NET

Answer 3

La plupart des chipsets USB avec des pilotes. Silicon Labs en a un.

Answer 4

Il y a une boîte à outils générique WinDriver pour l'écriture de pilotes USB en mode utilisateur qui prennent en charge # .NET ainsi

Answer 5

J'ai essayé d'utiliser SharpUSBLib et foiré mon ordinateur (besoin d'un système de restauration). Arrivé à un collègue sur le même projet aussi.

J'ai trouvé une alternative dans LibUSBDotNet: http://sourceforge.net/projects/libusbdotnet Havn't l'a employé beaucoup encore mais semble bon et récemment mis à jour (contrairement à Sharp).

EDIT: À la mi-février 2017, LibUSBDotNet a été mis à jour il y a environ 2 semaines. Pendant ce temps SharpUSBLib n'a pas été mis à jour depuis 2004.

Answer 6

Il y a un tutoriel sur l'obtention de la bibliothèque SharpUSBLib et les pilotes HID qui travaillent avec C# ici:

http://www.developerfusion.com/article/84338/making-usb-c-friendly/

Answer 7

Je suis devenu une interface à un Teensy fonctionne assez bien , en utilisant this article

Answer 8

Je recommanderais LibUSBDotNet, la bibliothèque que j'utilise depuis 2 ans. Si vous devez travailler avec un périphérique USB (envoyer des demandes, traiter des réponses), cette bibliothèque était la meilleure solution que je pouvais trouver.

Plus:

• A toutes les méthodes dont vous avez besoin pour travailler en mode de synchronisation ou asynch.
• Code source fourni
• Suffisamment d'échantillons pour commencer à l'utiliser immédiatement.

Moins:

• documentation médiocre (il est le problème commun pour les projets open source). Fondamentalement, vous pouvez trouver juste une description commune des méthodes dans le fichier d'aide CHM et c'est tout. Mais je trouve toujours des échantillons fournis et le code source est suffisant pour le codage. Parfois, je vois un comportement étrange et je veux savoir pourquoi il a été implémenté de cette manière et ne peut même pas obtenir un indice ...
• Semble plus supporté. La dernière version a été publiée en octobre 2010. Et il est difficile d'obtenir des réponses parfois.

Answer 9

J'ai utilisé le code suivant pour détecter les périphériques USB sont 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 lors de l'exécution lors de la fermeture.

Answer 10

Si vous avez National Instruments logiciel sur votre PC, vous pouvez créer un pilote USB en utilisant leur "NI-VISA Driver Wizard".

étapes pour créer le pilote USB: http://www.ni.com/tutorial/4478/en/

Une fois que vous avez créé le pilote que vous pourrez écrire et lire des octets à tout périphérique USB.

Assurez-vous que le conducteur est vu par Windows sous le Gestionnaire de périphériques:

C# Code:

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(); 

Hope this helps quelqu'un.