[C] libusb documentation

Je suis dans le même cas.
Je voudrais entre autre savoir comment gérer des interruptions car je veux "écouter" un périphérique usb;

voilà un bout de code que j'ai pu faire avec libusb (il permet de lire les données envoyées par un lecteur code barre)
Code:
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#include <stdio.h>
#include <usb.h>
#include <string.h>
 
 
void driver_init(void) {               
	usb_init();                    //Initialisation de la librairie (par example determine le chemin du repertoire des bus et peripheriques)
	usb_find_busses();             // Enumère tous les bus USB du systemes
	usb_find_devices();            // Enumère tous les peripheriques sur tous les Bus présents)
}
 
void usb_scan(void) {
	struct usb_bus *busses;
	struct usb_bus *bus;
	struct usb_device *dev,*fdev;
	printf("\n -- Scanning USB devices -- \n");
	for (bus = usb_busses; bus; bus = bus->next) { // Parcours tous les bus USB
		for (dev = bus->devices; dev; dev = dev->next) {  // Pour chaque bus, parcours tous les appareils branchés
			printf("     * bus : %s Device %s : id Vendor: %04X | id Product : %04X | Manufacturer Name : | Product Name : \n", bus->dirname,dev->filename ,dev->descriptor.idVendor,dev->descriptor.idProduct);
		}
	}
}
 
struct usb_device *usb_find_My_device(int idV, int idP) {
	struct usb_bus *busses;
	struct usb_bus *bus;
	struct usb_device *dev,*fdev;
	printf("\n -- Searching USB device (%04X|%04X) -- \n", idV, idP);
	for (bus = usb_busses; bus; bus = bus->next) { // Parcours tous les bus USB
		for (dev = bus->devices; dev; dev = dev->next) {   // Pour chaque bus, parcours tous les appareils branchés
			if ((dev->descriptor.idVendor == idV) && (dev->descriptor.idProduct ==idP )) { // on vérifie si les coordonnées (id vendeur; id produit) de notre appareil corespond
				printf("     * Found.\n");
				return(dev);
			}
		}
	}
	printf("      ! Nothing found !\n");
	return(0);
}
 
void unlinkKernelDriver(usb_dev_handle *hdl) { // fonction pour détacher le driver du kernel (usbhid)
	char str[100];
	printf("\n -- Procedure to unlink Kernel Driver --\n");
	strcpy(&str[0], "truc"); // au cas où la variable soit vide ... parce qu'il faut entrer dans la boucle while.
	while (strlen(str) != 0) {  // boucle pour détacher le driver du kernel (celui qui considère le lecteur code barre comme un clavier)
		memset(&str[0], 0, 100); // réinitialisation de la variable 
		if (usb_get_driver_np(hdl, 0, &str[0], 100) >=0 )printf("     * Checking Kernel Driver --> %s\n", str);  // récupération du driver lié à l'appareil
			else printf("       ! Not able to retrieve Kernel Driver or Kernel Driver allready unlinked !\n");
		if (strlen(str)>0) { // si on en trouve un ...
			printf("     * Unlinking Kernel Driver ...\n"); // on le détache.
			if (usb_detach_kernel_driver_np(hdl,0) !=0) printf("  ! Not able to unlink Kernel Driver or Kernel Driver allready unlinked !\n"); else printf("Done.\n");
		}
	}
}
 
 
void listEndpoints(struct usb_device *device) { // navigation à travers l'arborescence de variables
	char endPointType [4][50] = {"Control", "Isochronous", "Bulk", "Interrupt"};
	printf("\n -- Listing endpoints --\n");
	printf("     * usb_device\n     *    config\n     *       interface(%d)\n", device->config->bNumInterfaces);
	for(int i_interface = 0; i_interface< device->config->bNumInterfaces; i_interface++) {
		printf("     *          altsetting(%d)\n", device->config->interface[i_interface].num_altsetting);
		for(int i_altsetting=0; i_altsetting<device->config->interface[i_interface].num_altsetting; i_altsetting++) {
			printf("     *             endpoint(%d)\n", device->config->interface[i_interface].altsetting[i_altsetting].bNumEndpoints);
			for(int i_endpoint=0; i_endpoint<device->config->interface[i_interface].altsetting[i_altsetting].bNumEndpoints; i_endpoint++)
				printf("     *                0x0%02Xh (%s) - length=%d, packet_size=%d\n", device->config->interface[i_interface].altsetting[i_altsetting].endpoint[i_endpoint].bEndpointAddress, endPointType[device->config->interface[i_interface].altsetting[i_altsetting].endpoint[i_endpoint].bmAttributes & USB_ENDPOINT_TYPE_MASK], device->config->interface[i_interface].altsetting[i_altsetting].endpoint[i_endpoint].bLength, device->config->interface[i_interface].altsetting[i_altsetting].endpoint[i_endpoint].wMaxPacketSize);
		}
	}
}
 
void resetDevice(usb_dev_handle *hdl) { // reset du device
	printf("\n -- Resetting device -- \n");
	if (usb_reset(hdl)<0) printf("       ! Not able to reset device !\n"); else printf("     * Done.\n");
 
}
 
 
void readDevice(usb_dev_handle *hdl) { // lecture des données du device
	char donnees1[16];
	char donnees2[16];
	memset(&donnees1[0], 0, sizeof(donnees1)); // on remet les variables à 0
	memset(&donnees2[0], 0, sizeof(donnees2)); // on remet les variables à 0
	printf("\n -- Beginning reading data -- \n");
 
	int enlecture=0; // pour gérer les retours à la ligne entre les listes de paquets
	int longueur1, longueur2;
	for(int j = 0; j<500; j++) { // on va faire 100 lectures de 20 millisecondes
		longueur1 = -1;
		longueur2 = -1;
		//if (usb_claim_interface(hdl, 0) ==0)
			longueur1 = usb_interrupt_read(hdl, 0x081, &donnees1[0], sizeof(donnees1), 30);
		//if (usb_claim_interface(hdl, 1) ==0)
			longueur2 = usb_interrupt_read(hdl, 0x082, &donnees2[0], sizeof(donnees2), 30);
		if (longueur1>enlecture) printf("\n"); // si au tour d'avant il n'y avait rien à lire et que maintenant il y a quelque chose
		if (longueur1 >=0) { // il y avait quelque chose à lire ...
			printf("     * %d bytes read on 0x081 : ", longueur1);
			for(int i=0; i<sizeof(donnees1); i++) {
				printf("%02X ", donnees1[i]);
				if ((i+1)%16 == 0) printf("\n");
			}
		}
		if (longueur2 >=0) { // il y avait quelque chose à lire ...
			printf("     * %d bytes read on 0x082 : ", longueur2);
			for(int i=0; i<sizeof(donnees2); i++) {
				printf("%02X ", donnees2[i]);
				if ((i+1)%16 == 0) printf("\n");
			}
		}
		enlecture = longueur1; // on remet à jour le petit flag
	}
}
 
 
int main (void) {
	char str[100];
 
	// *************  Initialise les devices *************
	driver_init();
 
	// *************  Scanne tous les devices (optionnel) *************
	usb_scan();
 
	// *************  Recherche du device *************
	struct usb_device *barCodeReader = usb_find_My_device(0x04D9, 0x1400);  // on recherche l'appareil "lecteur code barre"
	if (barCodeReader ==0) {  // si on ne l'a pas trouvé ...
		printf("       ! No Bar Code Reader found !\n");
		return 0;
	}
 
	// *************  Ouverture du device *************
	printf("\n -- Opening USB device (Vendor, Product) = (0x%04X,  0x%04X) --\n", barCodeReader->descriptor.idVendor, barCodeReader->descriptor.idProduct);
	usb_dev_handle *barCodeReaderHandle = usb_open(barCodeReader);  // ouverture du device
	if (!barCodeReaderHandle) { // si l'ouverture s'est mal passée ...
		printf("       ! Not able to open device !\n");
		return 0;
	} else printf("     * Device opened : ");
	if (usb_get_string_simple(barCodeReaderHandle, 1, &str[0], 50) >=0) printf("%s\n", str); // on récupère la description
		else printf("\n       ! Not able to retrieve Description !\n");
 
 
	// *************  Opérations sur le device *************
	unlinkKernelDriver(barCodeReaderHandle); // on détache le driver du Kernel (usbhid)
	listEndpoints(barCodeReader);
	resetDevice(barCodeReaderHandle);
	readDevice(barCodeReaderHandle);
	resetDevice(barCodeReaderHandle);
 
	// *************  Fermeture du device *************
	printf("\n -- Closing USB device (Vendor, Product) = (0x%04X,  0x%04X) -- \n", barCodeReader->descriptor.idVendor, barCodeReader->descriptor.idProduct);
	if (usb_close(barCodeReaderHandle) >=0) printf("     * Device closed.\n");
 
	return 0;
}
.. à compiler avec
gcc -std=c99 -lusb -o codebarre codebarre.c

le programme s'exécute en root