Discussion :

[Corendos]

Bonjour tout le monde
Y aurait-il des personnes qui pourrait m'aider pour communiquer avec un périphérique USB ?
Voila le problème: J'aimerai pouvoir gérer manuellement une liaison avec une manette, en l'occurrence une manette d'Xbox 360.
Je sais qu'il existe pas mal de bibliothèques qui le font mais elles n'exploitent pas toute les capacités offertes par la manette et c'est pourquoi je voudrai le faire moi même.
J'ai déjà trouvé ce lien : GamePad
Il explique comment communique la manette avec l'ordinateur: la taille de chaque paquets envoyés, l'ordre de ces paquets, etc...
Donc je cherche une personne qui sache comment envoyer/recevoir des données sur un port USB afin de gérer ces paquets.

Merci d'avance, Corendos

[Ekleog]

https://libusb.org permet de communiquer directement avec un périphérique, sans aucune abstraction. Il me semblait qu'il y avait une libusb2, mais je dois confondre avec libusb1 (libusb est restée très longtemps en v0.1).

Bon courage !

[djuju]

Il me semblait qu'il y avait une libusb2, mais je dois confondre avec libusb1

Non, je confirme. J'utilise libUSB très souvent. Pas de v2.

Par contre, je ne suis pas sur que je partirais de libUSB. Même si tu as toutes les spec du protocole de com, il va falloir implémenter toutes les séquences d'init, le calibrage etc...
De plus, si tu ne connais pas la norme USB, tu vas devoir apprendre. LibUSB tu peux pas faire plus bas niveau avant de coder toi même ton driver. Ca envoi des paquets et ça ouvre des requêtes pour en recevoir. Après à toi de savoir si tu dois faire du bulk, de l'isochronious ou autre, et de monter tes paquets. Avec USB, c'est hôte qui est le maître, donc pas mal de logique à coder. En plus, c'est de l'HID, donc une particularité de la norme puisque c'est les seuls devices synchrones.

Je repartirais du code source de GamePad et j'implémenterais ce qu'il te manque. Il doit déjà y avoir dedans de quoi communiquer avec la manette. Il ne reste donc qu'à supporter des commandes supplémentaires.

[Corendos]

Le problème c'est que leur code est pour Linux, or moi je suis sous Windows. Je pense que ça va poser problème...
Tu pense que c'est possible à partir de LibUSB ou pas du tout ?

[Ekleog]

D'après le site web de la libusb, il y a un port sur windows : https://libusb.org/wiki/windows_backend
(barre de recherche du site, "windows")

Donc ça ne devrait pas être un problème.

Après, je n'y connais pas grand chose en développement usb, donc je te conseilles de suivre plutôt les conseils de djuju.

(BTW... Une manette xbox sur un windows... Il n'y aurait pas un driver officiel, qui donc intégrerait toutes les capacités de la manette ?)

[djuju]

Le problème c'est que leur code est pour Linux, or moi je suis sous Windows. Je pense que ça va poser problème...

Effectivement, je ne connaissais pas cette contrainte.
GamePad est basé sur LibXenon qui compilable sous Cygwin. Tu peux toujours repartir de là. Mais je me doute (et je comprend) que la dépendance à Cygwin sera un problème.

Tu pense que c'est possible à partir de LibUSB ou pas du tout ?

Oui bien sur, c'est juste pas mal plus de travail.
Un beau projet, très intéressant qui t'apprendra beaucoup sur l'USB. En plus, comme libUSB est cross platform, si tu aboutis et que tu release en open source, tu aura le premier driver pour manette Xbox cross platform... De quoi rendre ton projet intéressant pour la communauté.

[djuju]

D(BTW... Une manette xbox sur un windows... Il n'y aurait pas un driver officiel, qui donc intégrerait toutes les capacités de la manette ?)

Oui, il y a un driver proprio, mais je sais pas s'il a les fonctionnalités nécessaires. Tout du moins, j'assume qu'il ne les a pas, ou qu'il pose d'autres problèmes, car Corendos a déjà du y jeter un oeil.

[Corendos]

Comme vous devez vous en douter, je suis débutant dans le domaine de la communication USB.
Au niveau du driver, je me trompe peut-être mais c'est seulement un fichier .sys ou .inf qui est dans les fichiers de Windows "C:/Windows/system32/etc" non ?
Donc je n'ai pas accès à des fonctions qui me permettent de faire ce que je veux ?
Si vous en savez plus que moi à ce sujet dites-le moi, parce que je gère pas trop tout ce qui est en dehors du PC(périphérique, etc...)

Je ne sais pas si ça peut aider mais en allant dans les propriétés de la manette j'ai trouvé que le pilote est le fichier xusb21.sys

Il me semble qu'il est possible de communiquer avec la manette avec la lib "SetupAPI"

Je continue mes recherches et je vous dit ce que je trouve.

[djuju]

Je vais essayé de te donner quelques bases pour démarrer.

Nous allons parlé de Windows. Donc de libUSB-Win32. Sous Linux la logique est un peu différente, mais le code restera compatible.

Quand tu branche un device USB, windows déclenche une séquence dites d'énumération et demande au device de s’identifier. Le périf répond en envoyant sa paire PID/VID (product/vendor ID). Tout device USB a un PID/VID, c'est ce qui permet de les identifier (d’ailleurs tu dois les acheter à l'org. USB).
Windows va alors cherché dans sa base de driver s'il y en a un qui permet de rouler le périf. Si oui, il le charge. Sinon, "nouveau périf détecté" etc...

Un driver est composé d'au moins 1 .inf et 1 .sys. Le .sys est le binaire, en fait le driver au sens propre. Le .inf décrit qui peut utiliser le driver, sous quels systèmes etc...

Quand tu télécharge libUSB, tu as un exe "inf-wizard.exe" qui va te permettre de générer facile le .inf à utiliser avec le .sys qu'ils te fournissent. Le wizard te demandera ta paire PID/VID. Tu peux la trouver en allant dans le device manager, puis en regardant les détails du périf ("hardware id" dans détail je crois). Si tu n'arrive pas à utiliser le wizard, fais moi signe, mais c'est plutôt simple.
Une fois que tu as ton .inf, fais un tour dedans. Tu vas voir c'est plutôt simple. C'est un ensemble de sections qui se références entre elles et qui forment des contraintes et des paramètres. Mais ne t’inquiète pas, tu n'aura pas à aller trop trifouiller la dedans.

Maintenant, tu as un .inf et un .sys. Ou plutôt des .sys, puisque tu en as 1 pour x86, 1pour x64 et 1 ia64. Ils sont dans des sous répertoires, tu peux les laisser la.
Tu pourrais aussi avoir un .cat. Le certificat du driver. [edit:suppr] Sinon, sous 7 t'installe pas à moins d'être en "test mode". Sous XP, c'est un simple avertissement.

Nous allons installer la manette. Assure toi qu'elle n'est pas déjà installée sous un autre driver. Si oui, désinstalle ce driver. Maintenant, branche la manette, windows la détecte. Donne lui le répertoire ou est ton .inf. Windows devrait installé ton driver.

Bon, tu es prêt à coder

Fais un nouveau projet et ajoutes y la lib fournie avec libUSB. Tu en as une pour à peu près chaque compilo qui tourne sous windows. Au pire, tu peux toujours la compiler depuis les sources.

Dans ton code, la première étape importante sera d'énumérer les devices disponibles (ceux supporter par libUSB) pour trouver la paire PID/VID de ta manette. Une fois trouvée, tu peux la connecter.
Ca devrait donné un truc comme ca:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
usb_init();
usb_set_debug(0); // Affiche des messages de debug... Toujours utilise ;)
 
usb_find_busses(); // Met à jour la liste des bus
usb_find_devices(); // Met à jour la liste des devices
 
usb_bus *pUsbBusses = usb_get_busses(); // Récupère les bus USB (les controllers)
 
// Pour chaque controller
for(usb_bus pBus = pUsbBusses; pBus; pBus = pBus->next) 
{
  // Pour chque device supporté par libUSB sur le controller
  for(usb_device pDevice = pBus->devices; pDevice; pDevice = pDevice->next) 
  {
    // Si c'est la paire PID/VID que je cherche
    if(pDevice->descriptor.idVendor == 0xEFEF && 
       pDevice->descriptor.idProduct == 0xFEFE) 
       {
         // Je connecte le device
         usb_dev_handle hDeviceHandle = usb_open(pDevice);
 
         if(hDeviceHandle)
         {
           if(usb_set_configuration(hDeviceHandle, 1) == 0)
           {
             if(usb_claim_interface(hDeviceHandle, 0) == 0)
             {
               // Ton device est connecté.
             }
           }
         }
       }
    }
  }

Quelques explications.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if(usb_set_configuration(hDeviceHandle, 1) == 0)

On dit dans quel mode on utilise la manette . Ce mode est prédéfini dans son firmware. C'est généralement 1. Les autre modes sont utilisés par exemple dans le cas d'une imprimante 2 en 1. Tu aura une config pour le scanner et une autre pour l'imprimante.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if(usb_claim_interface(hDeviceHandle, 0) == 0)

Maintenant on réclame l'utilisation du device pour ce mode. Si cette condition échoue, c'est sûrement parce que ta manette est utilisée par un autre process. Il s'agit d'un handle automatique, donc même si ton process plante, il sera automatiquement libéré.
Si ce "if" échoue, tu peux quand même utiliser la manette, mais tu sera sûrement en concurrence avec un autre process.

Maintenant que ta manette est connectée, tu peux commencer à utliser l'API de libUSB pour implémenter le protocle de communication.

Quant tu aura fini d'utiliser ta manette, tu dois releaser ton handle.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
usb_release_interface(hDeviceHandle, 1);
usb_close(hDeviceHandle);

Je sais que ça beaucoup en un morceau et que je ne rentre pas trop dans le détail, mais ça devrait te permettre de démarrer. Je crois que si je détaille plus, je pourrais écrire un bon moment (mais n'hésites pas si tu as des questions).

Bon courage

[Corendos]

Merci pour cette réponse qui m'a bien aidé, avant avec WinUSB, le programme n'arrivait pas à trouver le device(la manette), maintenant si.

Puisque tu m'as dit que je pouvais m'aider du code du site que j'ai donné, je suis allé analyser le code. J'ai pris un exemple très simple, changer le motif des leds: Ils envoient un tableau de char avec la fonction libusb_fill_interrupt_transfer(...); mais cette fonction n'existe pas sur le port pour Windows, il n'y a que usb_interrupt_write.

Je ne sais pas si ça a un rapport, mais WinUSB ne gère pas les transfert Isochronous et tu m'as dit que la manette fonctionnait certainement en Isochronous.

Donc j'attends ta réponse et je continue de chercher

[djuju]

J'ai pris un exemple très simple, changer le motif des leds: Ils envoient un tableau de char avec la fonction libusb_fill_interrupt_transfer(...); mais cette fonction n'existe pas sur le port pour Windows, il n'y a que usb_interrupt_write.

Héhé, bien vu. Tu commence à entrer dans le problème, ca fait plaisir.

Je ne suis pas sur du code que tu as modifié et je connais pas la doc par coeur, mais oui, c'est très probablement les mêmes fonctions (écrire sur un End Point choisit). Quand tu arrive à bas niveau, tu trouvera toujours les mêmes commandes, puisque c'est l'implémentation du protocole USB.

[Corendos]

Tu pense que ce sont les mêmes fonctions ?
Je ne suis pas vraiment sûr car en regardant la doc, le prototype des deux fonctions n'a rien à voir, enfin il y a quand même quelques point communs mais le prototype de LibUSB est plus complet:
-LibUSB:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

static void libusb_fill_interrupt_transfer (struct libusb_transfer *transfer, libusb_device_handle *dev_handle, unsigned char endpoint, unsigned char *buffer, int length, libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout)

-WinUSB:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout);

Après je ne peux pas voir plus loin si elles sont très proches puisqu'il ne me semble pas avoir accès au code source, enfin je vais chercher ça.

J'ai bien essayé d'envoyer un message à la manette avec usb_interrupt_write(); mais je n'ai aucune idée de quoi mettre pour l"endpoint car je ne voit pas très exactement ce que ça représente. Tu n'aurais pas un bon lien sur une explication clair et detaillé du protocole USB ?

Merci encore pour tes réponses

[djuju]

Tout d'abord, un petit errata:
LibUSB à bien un .cat, je sentais bien que j'écrivais une connerie hier
Ce .cat est généré par inf-wizard.exe.

Ensuite une question rapide:
Pourquoi tu parles sur WinUSB ? Tu as une base de code avec ou tu confonds ?
Je dis ça, parce que usb_interrupt_write c'est pas du WinUSB, c'est du libusb API v.0.1. ou du LibUSB-win32 qui est un port de libUSB API v.0.1.

Maintenant la réponse à ta question:

Tu pense que ce sont les mêmes fonctions ?

En se basant sur le fait que c'est du libUSB v.0.1, oui c'est pas mal la même chose.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
// LibUSB API v.0.1
 
// Envoie un transfert interrupt sur un end point
// dev : Handle sur ton device
// ep : End point de destination
// bytes : Données à écrire
// size : La taille de "bytes" en bytes
// timeout : Temps max d'attente pour le transfert.
int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// LibUSB API v.1.0
 
// Prépare un structure de transfert interrupt
// transfer : Structure à remplir
// dev : Handle sur ton device
// endpoint : Numéro du End Point de destination
// buffer : Données à écrire
// length : Taille en bytes des donnes à écrire
// callback : [Optionnel] Pointer sur une fonction de callback qui sera appelée en fin de tranfert ou NULL
// user_data : [Optionnel] Données à passer au callback ou NULL
// timeout : Temps max d'attente pour le transfert.
void libusb_fill_interrupt_transfer (struct libusb_transfer *transfer, libusb_device_handle *dev_handle, unsigned char endpoint, unsigned char *buffer, int length, libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout)
 
// Envoie un transfert 
int libusb_submit_transfer (struct libusb_transfer *transfer)

Tu vois qu'au final les choses sont pas mal les mêmes. À part le callback c'est pareil. Pour remplacer, si usb_interrupt_write retourne un succès, tu appelle le callback.
En gros, il s'agit de porter ton code intelligemment de l'API v.1.0 vers l'API v.0.1..

Bon, je me doute que tu te demandes ce qu'est un end point.
Pour faire simple, tu peux voir ça comme un socket en TCP/IP. Quand tu transfères des données dans un sens ou l'autre avec un device USB, il faut bien qu'il y ait des FIFO pour bufferiser tout ça. Un end point est toujours utiliser pour un type de transfert particulier (control/interrupt/bulk/iso.). C'est une FIFO qui est en lecture ou en écriture et qui contient un type de données particulier.
Par exemple, quand tu bouges les boutons de ta manette, ça doit remplir une FIFO d'un end point avec les données correspondantes. De ton coté, tu vas lire ce end point régulièrement pour récupérer ces données et les interpréter.

Bon courage !

[Corendos]

Salut,
Oui pardon, quand je parle de WinUSB je parle du port de LibUSB pour Windows, c'est vrai que depuis le début ca doit pas être facile à comprendre

Merci pour ton explication pour l'enpoint, tout est plus clair maintenant.

J'ai deux très bonnes nouvelles:
-J'ai réussi, en bidouillant un peu, à changer le motif des Leds et à mettre en marche les moteurs des vibreurs.
-j'ai aussi réussi a récupérer les données en provenance de la manette.

Je suis assez fier de moi

Par contre le seul inconvénient, vu que j'utilise Qt et son système de signaux/slot, ce n'est pas compatible avec Code::blocks.
Pense tu que jce serait une bonne idée de créer un thread à part qui s'occuperait d'aller lire les données périodiquement et les mettrait dans une structure partagé entre les deux thread?
Sinon je n'ai pas encore réfléchi à une autre idée.

Je mettrai peut être quelques screen du logiciel que j'ai fait avec Qt dans la soirée, histoire de le mettre au point.

[djuju]

Cool

Oui pardon, quand je parle de WinUSB je parle du port de LibUSB pour Windows, c'est vrai que depuis le début ca doit pas être facile à comprendre

C'est surtout que WinUSB existe aussi. C'est un driver générique proprio de MS.

Pense tu que jce serait une bonne idée de créer un thread à part qui s'occuperait d'aller lire les données périodiquement et les mettrait dans une structure partagé entre les deux thread?

Oui, au moins pour le com descendent (manette->pc) tu vas avoir besoin d'un thread à haute priorité qui vient lire en permanence les messages de la manette. Quand tu ouvre une requête sur la manette pour qu'elle t'envoie des données, tu dois absolument être là pour les recevoir au moment où elle les envoie. Sinon, tu perd ces données.