Travailler avec des périphériques USB in.NET

J'ai essayé D'utiliser SharpUSBLib et ça a bousillé mon ordinateur (j'avais besoin d'une restauration du système). Arrivé à un collègue sur le même projet.

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: en date de mi-février 2017, La mise à jour de LibUSBDotNet date d'il y a environ 2 semaines. Pendant ce temps SharpUSBLib n'a pas été mis à jour depuis 2004.

Le #usblib USB de la Bibliothèque .NET

j'ai utilisé le code suivant pour détecter quand 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 d'appeler la méthode Dispose() lors de la fermeture de votre demande. Sinon, vous recevrez une erreur COM object à l'exécution lors de la fermeture.

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

Pour:

• a toutes les méthodes dont vous avez besoin pour travailler en mode synch ou asynch.
• code Source fourni
• suffisamment d'échantillons pour commencer à utiliser tout de suite.

Inconvénients:

• documentation insuffisante (c'est un problème courant pour les projets open source). Fondamentalement, vous pouvez trouver juste description commune des méthodes dans le fichier d'aide de CHM et c'est tout. Mais je trouve que les échantillons fournis et le code source sont suffisants pour le codage. Juste des fois 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 obtenir un indice...
• ne semble plus supporté. La dernière version a été publiée en octobre 2010. Et il est difficile d'obtenir des réponses parfois.

il y a un tutoriel pour obtenir la bibliothèque SharpUSBLib et cacher les pilotes travaillant avec C# ici:

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

il y a une boîte à outils Générique WinDriver pour écrire les pilotes USB en mode utilisateur qui prennent en charge #.NET ainsi

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 aurez créé le pilote, vous pourrez écrire et lire des octets sur n'importe quel périphérique USB.

assurez-vous que le pilote est visible par les fenêtres 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();

J'espère que ça aidera quelqu'un.

la plupart des chipsets USB sont fournis avec des pilotes. Silicon Labs en a un.

j'ai obtenu une interface pour un Teensy fonctionne très bien, en utilisant cet article

j'ai essayé plusieurs de ces suggestions sans succès. J'ai fini par écrire une solution de travail en utilisant Java et la bibliothèque hid4java . En tant qu'application de la console , je peux l'utiliser à partir de C# en utilisant Process.Start() , en passant des paramètres ainsi qu'en lisant des réponses. Ceci fournit les e / s de base de HID mais sans les événements de connexion/déconnexion. Pour cela j'aurais besoin de le réécrire pour l'exécuter comme un démon/service et utiliser des pipes nommées ou un autre serveur/transport de client. Pour l'instant, c'est assez pour le travail effectué depuis la bibliothèque hi4java "fonctionne simplement".