Trabajar con dispositivos USB en .NET

Question

Usando .Net (C#), ¿cómo se puede trabajar con dispositivos USB?

Cómo puede detectar eventos USB (conexiones/desconexiones) y cómo se comunica con los dispositivos (lectura/escritura).

¿Hay una solución .Net nativa para hacer esto?

Answer 1

No existe una solución nativa (por ejemplo, bibliotecas del sistema) para esto. Esa es la razón por la cual SharpUSBLib existe como se menciona en moobaa.

Si desea instalar su propio controlador para dispositivos USB, puede consultar el SerialPort class of System.IO.Ports.

Answer 2

The #usblib USB Library for .NET

Answer 3

La mayoría de los conjuntos de chips USB vienen con los conductores. Silicon Labs tiene uno.

Answer 4

No es un conjunto de herramientas genéricas WinDriver para la escritura de los controladores USB en modo de usuario que soportan # .NET, así

Answer 5

He intentado usar SharpUSBLib y se confundieron mi ordenador (necesitaba una restauración del sistema). Sucedió a un compañero de trabajo en el mismo proyecto también.

He encontrado una alternativa en LibUSBDotNet: http://sourceforge.net/projects/libusbdotnet No la he usado demasiado pero parece estar bien actualizada recientemente (a diferencia de Sharp).

EDITAR: a partir de mediados de febrero de 2017, LibUSBDotNet se actualizó hace 2 semanas. Mientras tanto SharpUSBLib no se ha actualizado desde 2004.

Answer 6

Hay un tutorial en conseguir la biblioteca SharpUSBLib y los controladores HID que trabajan con C# aquí:

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

Answer 7

He conseguido una interfaz a un Teensy funcionando bastante bien , usando this article

Answer 8

Recomendaría LibUSBDotNet, la biblioteca que he estado utilizando durante 2 años. Si tiene que trabajar con un dispositivo USB (enviar solicitudes, procesar respuestas), esta biblioteca fue la mejor solución que pude encontrar.

Pros:

• Tiene todos los métodos necesarios para trabajar en el modo de sincronización o desincronizado.
• Código fuente proporcionado
• muestras suficientes para comenzar a utilizarlo de inmediato.

Contras:

• documentación pobre (que es un problema común para los proyectos de código abierto). Básicamente, puede encontrar una descripción común de los métodos en el archivo de ayuda de CHM, y eso es todo. Pero todavía encuentro que las muestras proporcionadas y el código fuente son suficientes para la codificación. A veces veo un comportamiento extraño y quiero saber por qué se implementó de esta manera y no puedo obtener siquiera una pista ...
• Parece que ya no es compatible. La última versión se publicó en octubre de 2010. Y a veces es difícil obtener respuestas.

Answer 9

que utiliza el código siguiente para detectar cuando los dispositivos USB se conectan y desconectada de mi equipo:

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


    } 

Usted tiene que asegurarse de llamar al método Dispose() cuando se cierra la aplicación. De lo contrario, recibirá un error de objeto COM en tiempo de ejecución al cerrar.

Answer 10

Si tiene software de National Instruments en su PC puede crear un controlador USB utilizando su "asistente del controlador NI-VISA" .

pasos para crear el controlador USB: http://www.ni.com/tutorial/4478/en/

Una vez que ha creado el conductor va a ser capaz de escribir y leer los bytes a cualquier dispositivo USB.

Asegúrese de que el conductor se ve por las ventanas en el Administrador de dispositivos:

C# Código:

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 

Uso:

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

Espero que esto ayude a alguien.