Comment se connecter à un périphérique USB (application UWP)

Article
01/12/2024

Dans Windows, vous pouvez écrire une application UWP qui interagit avec un périphérique USB.

Cet article aborde les points suivants :

Comment utiliser l’objet DeviceWatcher pour détecter des appareils
Comment ouvrir l’appareil pour la communication
Comment fermer l’appareil lorsque vous avez terminé de l’utiliser

API importantes

UsbDevice
DeviceWatcher

Lorsque vous écrivez une application UWP qui interagit avec un périphérique USB, l’application peut envoyer des commandes de contrôle, obtenir des informations sur l’appareil et lire et écrire des données vers/depuis des points de terminaison en bloc et des interruptions. Avant de pouvoir faire tout cela, vous devez trouver l’appareil et établir la connexion.

Avant de commencer

Il s’agit du premier sujet d’une série. Avant de commencer ce didacticiel, vous devez avoir créé un projet Visual Studio de base que vous pouvez étendre dans ce didacticiel. Pour plus d’informations, consultez Prise en main des applications UWP .
Les exemples de code sont basés sur l’exemple CustomUsbDeviceAccess. Vous pouvez télécharger l’exemple complet à partir de cette page de la galerie de codes.
Le périphérique USB utilisé dans le tutoriel est l’appareil SuperMUTT.
Pour pouvoir utiliser l’espace de noms Windows.Devices.Usb afin d’écrire une application Windows qui interagit avec un périphérique USB, le pilote Winusb.sys doit être chargé en tant que pilote de fonction. Winusb.sys est fourni par Microsoft et est inclus avec Windows dans le dossier \Windows\System32\drivers .

Organigramme : Recherche de l’appareil

Pour vous connecter à un périphérique USB, vous devez d’abord trouver l’appareil en fonction de différents modèles de découverte, puis vous y connecter :

Connectez-vous à n’importe quel périphérique USB avec un GUID d’interface de périphérique spécifique.
Connectez-vous à un périphérique USB avec un ID de fournisseur et un ID de produit spécifiques et qui a un GUID d’interface de périphérique spécifique.
Connectez-vous à un périphérique USB avec un ID de fournisseur et un ID de produit particuliers sans connaître le GUID de l’interface de l’appareil.
Connectez-vous à un périphérique USB dont la classe d’appareil est connue.

découverte de périphériques usb.

Concepts clés

Qu’est-ce qu’un GUID d’interface d’appareil ?

Un pilote de modèle noyau, lors de son initialisation, inscrit et expose un GUID appelé GUID de l’interface de périphérique. En règle générale, l’application utilise le GUID exposé pour rechercher le pilote associé et son appareil, puis ouvrir un handle sur l’appareil. Le handle récupéré est utilisé pour les opérations de lecture et d’écriture suivantes.

Toutefois, dans le cas de Winusb.sys, au lieu que le pilote expose le GUID de l’interface du périphérique, il peut être fourni de l’une des deux façons suivantes :

Dans les descripteurs MS OS de l’appareil. Le fabricant de l’appareil définit DeviceInterfaceGUID en tant que propriété personnalisée dans le descripteur de propriétés étendues de l’appareil. Pour plus d’informations, consultez le document « Descripteurs de propriétés étendues » dans Les descripteurs de système d’exploitation Microsoft.
Si vous avez installé Winusb.sys manuellement via un INF personnalisé, l’INF a inscrit un GUID dans l’INF. Consultez Installation de WinUSB (Winusb.sys).

Si un GUID d’interface d’appareil est trouvé pour l’appareil, votre application UWP peut rechercher tous les appareils qui correspondent à ce GUID d’interface d’appareil.

Comment l’identification des périphériques USB s’affiche-t-elle dans Windows ?

Chaque périphérique USB doit avoir deux informations : l’ID du fournisseur et l’ID de produit.

USB-IF attribue ces identificateurs et le fabricant de l’appareil doit les exposer dans l’appareil. Alors, comment pouvez-vous obtenir ces informations ?

Même lorsque l’appareil n’a pas de pilote de périphérique chargé, c’est-à-dire que Windows le détecte comme un « appareil inconnu », vous pouvez toujours afficher les identificateurs dans le Gestionnaire de périphériques dans la valeur de la propriété Id matériel. Cette valeur est une combinaison de ces deux identificateurs. Par exemple, pour l’appareil SuperMUTT, l’ID matériel est « USB\VID_045E&PID_F001 » ; l’ID du fournisseur est « 0x045E » et l’ID de produit est « 0xF001 ».
S’il existe un INF pour l’appareil, obtenez cette chaîne à partir de la section Modèles .
Vous pouvez inspecter différents paramètres du Registre. Le moyen le plus simple est de voir le

<ID matérielHKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Enum\USB\>

Pour plus d’informations, consultez Entrées du registre de périphériques USB.
L’ID matériel est utilisé par le manifeste de l’application pour identifier l’appareil.

<Device Id="vidpid :045e f001 »>

Votre application UWP peut trouver tous les appareils qui correspondent à un fournisseur et des ID de produit spécifiques. Vous pouvez affiner les résultats de la recherche en spécifiant le GUID de l’interface de l’appareil.

Que sont les classes de périphériques USB ?

La plupart des périphériques USB sont conformes aux spécifications de classe d’appareil approuvées par USB-IF. En utilisant ces spécifications, les appareils de nature similaire peuvent présenter leurs fonctionnalités de manière standard. Le plus grand avantage de cette approche est que l’appareil peut utiliser un pilote de classe intégré fourni par Microsoft ou le pilote de Winusb.sys générique.

Certains appareils peuvent ne pas suivre une spécification USB-IF. Au lieu de cela, ils exposent des fonctionnalités définies par le fournisseur . Pour ces appareils, le fournisseur doit fournir le pilote de périphérique ou Winusb.sys peut être utilisé.

Qu’un appareil soit défini par le fournisseur ou conforme à une classe d’appareil, il doit décrire les informations relatives à cette classe d’appareil :

Code de classe : indique la classe d’appareil à laquelle appartient l’appareil.
Code de sous-classe : dans la classe d’appareil, indique la sous-classe de l’appareil.
Code de protocole : protocole utilisé par l’appareil.

Par exemple, l’appareil SuperMUTT est un appareil défini par le fournisseur et que les informations indiquées par le code de classe sont FF. Si votre appareil affiche le code de classe FEh, le code de sous-classe 02h et le code de protocole 00h, vous pouvez conclure qu’il s’agit d’un appareil pont IrDA conforme à la classe. Votre application UWP peut communiquer avec les appareils qui appartiennent à ces classes d’appareils :

ActiveSync
CdcControl
DeviceFirmwareUpdate
Irda
Mesure
PalmSync
PersonalHealthcare
Physique
VendorSpecific

Votre application UWP peut trouver tous les appareils qui correspondent à un ensemble spécifique de codes de classe, de sous-classe et de protocole.

Obtenir la chaîne AQS (Advanced Query Syntax) pour l’appareil

Générez une chaîne de requête avancée (AQS) qui contient des informations d’identification sur l’appareil que vous souhaitez détecter. Vous pouvez générer la chaîne en spécifiant les ID de fournisseur/produit, le GUID de l’interface d’appareil ou la classe d’appareil.

Si vous souhaitez fournir l’ID de fournisseur/id de produit ou le GUID de l’interface de l’appareil, appelez n’importe quelle surcharge de GetDeviceSelector.

Dans l’exemple de l’appareil SuperMUTT, GetDeviceSelector récupère une chaîne AQS similaire à cette chaîne :

"System.Devices.InterfaceClassGuid:="{DEE824EF-729B-4A0E-9C14-B7117D33A817}" AND System.Devices.InterfaceEnabled:=System.StructuredQueryType.Boolean#True AND System.DeviceInterface.WinUsb.UsbVendorId:=1118 AND System.DeviceInterface.WinUsb.UsbProductId:=61441"

Note Notez que le GUID de l’interface d’appareil qui apparaît dans la chaîne n’est pas celui que vous avez spécifié. Ce GUID est le GUID d’interface d’appareil réel inscrit par Winusb.sys pour les applications UWP.
Si vous connaissez la classe d’appareil de l’appareil ou ses codes de classe, de sous-classe et de protocole, appelez GetDeviceClassSelector pour générer la chaîne AQS.

Créez un objet UsbDeviceClass en spécifiant les valeurs des propriétés ClassCode, SubclassCode et ProtocolCode . Sinon, si vous connaissez la classe d’appareil de l’appareil, vous pouvez appeler le constructeur en spécifiant une propriété UsbDeviceClasses particulière.

Recherche de l’appareil : la méthode de base

Il s’agit du moyen le plus simple de trouver un périphérique USB. Pour plus d’informations, consultez Démarrage rapide : énumération des appareils couramment utilisés.

Passez la chaîne AQS récupérée à FindAllAsync. L’appel récupère un objet DeviceInformationCollection .
Effectuez une boucle dans la collection. Chaque itération obtient un objet DeviceInformation .
Obtenez la valeur de la propriété DeviceInformation.Id . La valeur de chaîne est le chemin d’instance de l’appareil. Par exemple, « \\\\ ?\USB#VID_045E&PID_078F#6&1b8ff026&0&5#{dee824ef-729b-4a0e-9c14-b7117d33a817} ».
Appelez FromIdAsync en passant la chaîne de instance appareil et obtenez l’objet UsbDevice. Vous pouvez ensuite utiliser l’objet UsbDevice pour effectuer d’autres opérations, telles que l’envoi d’un transfert de contrôle. Lorsque l’application a fini d’utiliser l’objet UsbDevice , l’application doit la libérer en appelant Close. Note Lorsque l’application UWP s’interrompt, l’appareil est fermé automatiquement. Pour éviter d’utiliser un handle obsolète pour les opérations futures, l’application doit publier la référence UsbDevice .

    private async void OpenDevice()
    {
        UInt32 vid = 0x045E;
        UInt32 pid = 0x0611;

        string aqs = UsbDevice.GetDeviceSelector(vid, pid);

        var myDevices = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(aqs);

        try
        {
            usbDevice = await UsbDevice.FromIdAsync(myDevices[0].Id);
        }
        catch (Exception exception)
        {
            ShowStatus(exception.Message.ToString());
        }
        finally
        {
            ShowStatus("Opened device for communication.");
        }

    }

Rechercher l’appareil à l’aide de DeviceWatcher

Vous pouvez également énumérer les appareils de manière dynamique. Ensuite, votre application peut recevoir une notification si des appareils sont ajoutés ou supprimés, ou si les propriétés de l’appareil changent. Pour plus d’informations, consultez Comment obtenir des notifications si des appareils sont ajoutés, supprimés ou modifiés.

Un objet DeviceWatcher permet à une application de détecter dynamiquement les appareils à mesure qu’ils sont ajoutés et supprimés du système.

Créez un objet DeviceWatcher pour détecter quand l’appareil est ajouté ou supprimé du système. Vous devez créer l’objet en appelant CreateWatcher et en spécifiant la chaîne AQS.
Implémentez et inscrivez des gestionnaires pour les événements Added et Removed sur l’objet DeviceWatcher . Ces gestionnaires d’événements sont appelés lorsque des appareils (avec les mêmes informations d’identification) sont ajoutés ou supprimés du système.
Démarrez et arrêtez l’objet DeviceWatcher .

L’application doit démarrer l’objet DeviceWatcher en appelant Start afin qu’elle puisse commencer à détecter les appareils à mesure qu’ils sont ajoutés ou supprimés du système. À l’inverse, l’application doit arrêter DeviceWatcher en appelant Stop, lorsqu’il n’est plus nécessaire de détecter les appareils. L’exemple comporte deux boutons qui permettent à l’utilisateur de démarrer et d’arrêter DeviceWatcher.

Cet exemple de code montre comment créer et démarrer un observateur d’appareil pour rechercher des instances de l’appareil SuperMUTT.

void CreateSuperMuttDeviceWatcher(void)
{
    UInt32 vid = 0x045E;
    UInt32 pid = 0x0611;

    string aqs = UsbDevice.GetDeviceSelector(vid, pid);

    var superMuttWatcher = DeviceInformation.CreateWatcher(aqs);

    superMuttWatcher.Added += new TypedEventHandler<DeviceWatcher, DeviceInformation>
                              (this.OnDeviceAdded);

    superMuttWatcher.Removed += new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>
                            (this.OnDeviceRemoved);

    superMuttWatcher.Start();
 }

Ouvrir l’appareil

Pour ouvrir l’appareil, l’application doit démarrer une opération asynchrone en appelant la méthode statique FromIdAsync et en passant le chemin d’instance de l’appareil (obtenu à partir de DeviceInformation.Id). Ce résultat de cette opération obtient un objet UsbDevice , qui est utilisé pour les communications futures avec l’appareil, telles que l’exécution de transferts de données.

Une fois que vous avez terminé d’utiliser l’objet UsbDevice , vous devez le libérer. En libérant l’objet, tous les transferts de données en attente sont annulés. Les routines de rappel d’achèvement pour ces opérations sont toujours appelées avec l’erreur annulée ou l’opération terminée.

Les applications C++ doivent libérer la référence à l’aide de la mot clé de suppression. Les applications C#/VB doivent appeler la méthode UsbDevice.Dispose . Les applications JavaScript doivent appeler UsbDevice.Close.

Le FromIdAsync échoue si l’appareil est en cours d’utilisation ou est introuvable.

Partager via