[USB] LibUsb error 9 : pipe error

Version imprimable

Bonjour,

J'essaie de me faire un petit driver pour communiquer avec un thermomètre usb en utilisant la librairie LibUsb (org.usb4java.LibUsb). Je voudrais l'utiliser depuis un Raspberry Pi (Model 3b, en os linux-arm, distribution noobs).

Je teste mon code sur le raspberry mais dès que je veux envoyer un Control Packet j'ai l'erreur : org.usb4java.LibUsbException: USB error 9: Control transfer failed: Pipe error

Voici mon code :

classe main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public class usbDriver {
 
	public static void main(String[] args) {
		Communication2 com = new Communication2();
		try {
			com.trouverDevice();
			com.preparerCom();
			com.testCom();
			com.terminerCom();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

classe communication 2 :

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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
public class Communication2 {
 
	/** vendor ID du thermometre */
    private static final short VENDOR_ID = 0x1941;
 
    /** product ID du thermometre  */
    private static final short PRODUCT_ID = (short) 0x8021;
 
    /** interface active du thermometre  */
    private static final byte INTERFACE_ID = 0x0;
 
    /** endpoint sur l'interface active du thermometre  */
    private static final byte ENDPOINT_ID = (byte) 0x81;
 
    private Context contexte = null;
    private Device device = null;
    DeviceHandle handle = null;
 
	private boolean pret;
	private boolean detach = false;
	private boolean trouve = false;
 
 
 
	public Communication2() {
		pret = false;
	}
 
 
 
	public void trouverDevice() throws SecurityException, UsbException{
		// avec libUsb
		// Create the libusb context
        Context context = new Context();
 
        // Initialize the libusb context
        int result = LibUsb.init(context);
        if (result < 0)
        {
            throw new LibUsbException("Unable to initialize libusb", result);
        }
        // Read the USB device list
        DeviceList list = new DeviceList();
        result = LibUsb.getDeviceList(context, list);
        if (result < 0)
        {
            throw new LibUsbException("Unable to get device list", result);
        }
        try
        {
            // Iterate over all devices and list them
            for (Device device: list)
            {
                int address = LibUsb.getDeviceAddress(device);
                int busNumber = LibUsb.getBusNumber(device);
                DeviceDescriptor descriptor = new DeviceDescriptor();
                result = LibUsb.getDeviceDescriptor(device, descriptor);
                if (result < 0)
                {
                    throw new LibUsbException(
                        "Unable to read device descriptor", result);
                }
                if (descriptor.idVendor() == VENDOR_ID && descriptor.idProduct() == PRODUCT_ID){
                	System.out.println("Thermometre Pearl NC-7004 detecté !");
                	System.out.println(descriptor.toString());
                	this.device = device;
                	this.trouve=true;
                } 
            }
        }
 
 
        finally
        {
            // Ensure the allocated device list is freed
            //LibUsb.freeDeviceList(list, true);
        }
        // Deinitialize the libusb context	
	}
 
		public boolean preparerCom() throws Exception{
 
			if (!this.trouve) return false;
 
			this.contexte = new Context();
			int result = LibUsb.init(contexte);
 
			// reclamer le handle
			System.out.println("claim device handle");
			this.handle = new DeviceHandle();
			result = LibUsb.open(this.device, handle);
			if (result != LibUsb.SUCCESS) throw new LibUsbException("Unable to open USB device", result);
 
 
			detach = LibUsb.hasCapability(LibUsb.CAP_SUPPORTS_DETACH_KERNEL_DRIVER);
			detach = true; // pour forcer le claim sur le kernel
			detach = detach && (LibUsb.kernelDriverActive(handle, INTERFACE_ID)==1?true:false);
 
			System.out.println(LibUsb.hasCapability(LibUsb.CAP_SUPPORTS_DETACH_KERNEL_DRIVER));
			System.out.println((LibUsb.kernelDriverActive(handle, INTERFACE_ID)));
			System.out.println(detach);
 
			// Detach the kernel driver
			if (detach)
			{
				System.out.println("tentative de detacher le kernel");
			    result = LibUsb.detachKernelDriver(handle,  INTERFACE_ID);
			    if (result != LibUsb.SUCCESS) throw new LibUsbException("Unable to detach kernel driver", result);
			}
			detach = true;	
 
 
			System.out.println("claim interface");
			result = LibUsb.claimInterface(handle, INTERFACE_ID);
			if (result != LibUsb.SUCCESS) throw new LibUsbException("Unable to claim interface", result);
 
 
			this.pret=false;
			return this.pret;
		}
 
 
 
		public void testCom(){
			if (!this.pret) return;
 
			ByteBuffer buffer = ByteBuffer.allocate(18);
 
 
			// LibUsb.fillControlSetup(buffer, (byte)0x80, (byte)0x6,
			//		(short)0x1, (short)0x0, (short)0x1200);
 
			ByteBuffer buffer2 = ByteBuffer.allocateDirect(18);
 
			int transfered = LibUsb.controlTransfer(handle,(byte)0x80,(byte)0x6,(short)0x1,(short)0x0,buffer2,2000L);
			if (transfered < 0) throw new LibUsbException("Control transfer failed", transfered);
			System.out.println(transfered + " bytes sent");
 
			String test;
			String test2;
			if (buffer2.hasArray()) {
				for(int i =0;i<buffer2.array().length;i++){
					System.out.format("%02x",buffer2.array()[i]);
				}
 
 
			     test=  new String(buffer.array(),
			    		buffer.arrayOffset() + buffer.position(),
			    		buffer.remaining());
			} else {
			    final byte[] b = new byte[buffer.remaining()];
			    buffer.duplicate().get(b);
			    test =  new String(b);
			}
			System.out.println(test);
 
 
		}
 
 
 
 
		public void terminerCom() throws Exception{
			if (this.pret){
				if (this.detach)
				{
				    int result = LibUsb.attachKernelDriver(handle,  INTERFACE_ID);
				    if (result != LibUsb.SUCCESS) throw new LibUsbException("Unable to re-attach kernel driver", result);
				}
 
 
 
				LibUsb.close(this.handle);
				this.trouve = false;
				this.pret = false;
			}
		}
 
 
 
	}

L'erreur se produit quand j'appelle LibUsb.ControlTransfer alors que je veux juste transférer le paquet de contrôle GET DEVICE DESCRIPTOR.

Je pense que la communication est bien initialisée à ce moment là (le handle est bien initialisé, ainsi que l'interface qui a été detachée du Kernel pour m'être attribuée).

Voici la sortie console totale :

Citation:

Device Descriptor:
bLength 18
bDescriptorType 1
bcdUSB 1.10
bDeviceClass 0 Per Interface
bDeviceSubClass 0
bDeviceProtocol 0
bMaxPacketSize0 8
idVendor 0x1941
idProduct 0x8021
bcdDevice 1.00
iManufacturer 0
iProduct 0
iSerial 0
bNumConfigurations 1

claim device handle
false
0
false
claim interface
org.usb4java.LibUsbException: USB error 9: Control transfer failed: Pipe error
at usbDriver.Communication2.testCom(Communication2.java:171)
at usbDriver.usbDriver.main(usbDriver.java:36)
root@raspberrypi:/home/pi/Desktop/execUsbDriver# java -jar usbDriver_executable.jar
java.lang.IllegalArgumentException: handle must not be null
at org.usb4java.LibUsb.controlTransfer(Native Method)
at usbDriver.Communication2.testCom(Communication2.java:170)
at usbDriver.usbDriver.main(usbDriver.java:36)

1 pièce(s) jointe(s)

J'ai finalement réussi à communiquer avec mon équipement ! Le problème venait des requêtes envoyées qui n'étaient pas exactes.

Maintenant j'aimerais m'attaquer au gros du problème : récupérer de la donnée du thermomètre. Avec un sniffer Usb j'ai vu que je devais envoyer un paquet de contrôle suivi de 8 Bytes de variable dans le control pipe. Ensuite sur l'endpoint 0x81 l'équipement devrait renvoyer 4 * 8 bytes de données en INTERRUPT. J'ai testé ça avec un outil de prototypage Usb :

Pièce jointe 223336

A priori je dois faire un transfert asynchrone. J'ai testé le code suivant sans sucés pour l'instant :

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
 
public void testCom(){
        if (!this.pret) return;
 
        ByteBuffer buffer = ByteBuffer.allocateDirect(18);
        buffer.rewind();
        // descriptor device
        int transfered = LibUsb.controlTransfer(handle,
                LibUsb.ENDPOINT_IN,LibUsb.REQUEST_GET_DESCRIPTOR,(short)0x0100,(short)0x0000,buffer,2000L);
        if (transfered < 0) throw new LibUsbException("Control transfer failed", transfered);
        System.out.println(transfered + " bytes sent");
 
        System.out.println("--- DEVICE DESCRIPTOR ---");
        System.out.println(byteBuffer2String(buffer));
        System.out.println();
 
        buffer = ByteBuffer.allocateDirect(9);
        // descriptor configuration
        transfered = LibUsb.controlTransfer(handle,
                LibUsb.ENDPOINT_IN,LibUsb.REQUEST_GET_DESCRIPTOR,(short)0x0200,(short)0x0000,buffer,2000L);
        if (transfered < 0) throw new LibUsbException("Control transfer failed", transfered);
        System.out.println(transfered + " bytes sent");
 
        System.out.println("--- CONFIGURATION DESCRIPTOR ---");
        System.out.println(byteBuffer2String(buffer));
        System.out.println();
 
        buffer = ByteBuffer.allocateDirect(8);
        // descriptor string
        transfered = LibUsb.controlTransfer(handle,
                LibUsb.ENDPOINT_IN,LibUsb.REQUEST_GET_DESCRIPTOR,(short)0x0300,(short)0x0409,buffer,2000L);
        if (transfered < 0) throw new LibUsbException("Control transfer failed", transfered);
        System.out.println(transfered + " bytes sent");
 
        System.out.println("--- DESCRIPTOR STRING ---");
        System.out.println(byteBuffer2String(buffer));
        System.out.println();
 
        System.out.println("TRYING TO GET DATA  ...");
 
        ByteBuffer bufferArgCmd = ByteBuffer.allocateDirect(16);
        /*bufferArgCmd.put((byte)0x21);
        bufferArgCmd.put((byte)0x09);
        bufferArgCmd.put((byte)0x02);
        bufferArgCmd.put((byte)0x00);
        bufferArgCmd.put((byte)0x00);
        bufferArgCmd.put((byte)0x00);
        bufferArgCmd.put((byte)0x08);
        bufferArgCmd.put((byte)0x00);*/
 
        bufferArgCmd.put((byte)0xA1);
        bufferArgCmd.put((byte)0x00);
        bufferArgCmd.put((byte)0x00);
        bufferArgCmd.put((byte)0x20);
        bufferArgCmd.put((byte)0xA1);
        bufferArgCmd.put((byte)0x00);
        bufferArgCmd.put((byte)0x00);
        bufferArgCmd.put((byte)0x20);
        bufferArgCmd.rewind();
 
        ByteBuffer bufferResCmd = ByteBuffer.allocateDirect(4);
        bufferResCmd.get();
        bufferResCmd.get();
 
        ByteBuffer bufferData = ByteBuffer.allocateDirect(32);
 
 
        ByteBuffer buffer81 = BufferUtils.allocateByteBuffer(32);
        // buffer81.put(data);
        Transfer transfer = LibUsb.allocTransfer(0);
        LibUsb.fillInterruptTransfer(transfer, handle, ENDPOINT_ID, bufferData,
            receiveData, null, 3000L);
        LibUsb.fillControlSetup(bufferArgCmd,(byte)0x21,(byte)0x09,(short)0x0200,(short)0x0,(short)0x08);
        // LibUsb.fillControlTransfer(transfer, handle, bufferArgCmd,
             //   sendData, null, 2000L);
        System.out.println("doing interrupt transfer to device");
        int result = LibUsb.submitTransfer(transfer);
        if (result != LibUsb.SUCCESS)
        {
            throw new LibUsbException("Unable to submit transfer", result);
        }
 
        System.out.println("Resultat du transfert : ");
        System.out.println(byteBuffer2String(bufferData));
    }
 
    // This callback is called after the ADB CONNECT message header is
    // sent and sends the ADB CONNECT message body.
    final TransferCallback receiveData = new TransferCallback()
    {
        @Override
        public void processTransfer(Transfer transfer)
        {
            System.out.println(transfer.actualLength() + " bytes received !!!! ");
            // write(handle, CONNECT_BODY, bodySent);
            // LibUsb.freeTransfer(transfer);
        }
    };
 
 // This callback is called after the ADB CONNECT message header is
    // sent and sends the ADB CONNECT message body.
    final TransferCallback sendData = new TransferCallback()
    {
        @Override
        public void processTransfer(Transfer transfer)
        {
            System.out.println("send command to device");
            // write(handle, CONNECT_BODY, bodySent);
            // LibUsb.freeTransfer(transfer);
        }
    };

La réponse console est ci-dessous :

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
 
> Thermometre Pearl NC-7004 detecté !
Device Descriptor:
  bLength                 18
  bDescriptorType          1
  bcdUSB                1.10
  bDeviceClass             0 Per Interface
  bDeviceSubClass          0
  bDeviceProtocol          0
  bMaxPacketSize0          8
  idVendor            0x1941
  idProduct           0x8021
  bcdDevice             1.00
  iManufacturer            0
  iProduct                 0
  iSerial                  0
  bNumConfigurations       1
 
claim device handle
false
0
false
claim interface
18 bytes sent
--- DEVICE DESCRIPTOR ---
1201 1001 0000 0008 4119 2180 0001 0000 0001
 
9 bytes sent
--- CONFIGURATION DESCRIPTOR ---
0902 2200 0101 0080 32
 
4 bytes sent
--- DESCRIPTOR STRING ---
0403 0904 0000 0000
 
tentative de communication de la requete de données ...
doing interrupt transfer to device
Resultat du transfert :
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
java.lang.IllegalStateException: deviceHandlePointer is not initialized
        at org.usb4java.LibUsb.attachKernelDriver(Native Method)
        at usbDriver.Communication2.terminerCom(Communication2.java:313)
        at usbDriver.usbDriver.main(usbDriver.java:37)

Auriez-vous des conseils à me donner pour faire fonctionner ce transfert ?

11/08/2017, 13h56
sofiasafia

Bonjour,

Je sais que ça fait longtemps que vous avez publié votre problème. Mais maintenant j'ai le même problème que toi.
En fait je voulais aussi envoyer un message à mon device (lecteur de chèque). J'ai essayé en premier lieu bulktransfer mais malheureusement il n'a pas marché parce que mon périphérique n'a qu'un seul endpoint IN et pour transférer de l'ordinateur au périphérique j'en ai besoin d'un endpoint OUT. Après quelque recherche, j'ai trouvé que je peux utiliser le mode de transfert "controltransfert" avec un endpoint 0. J'ai fait cela, mais quand j’exécute mon programme ça marche pas en m'affichant un message que mes paramètres sont invalides. Peut tu m'aider ou bien me clarifier les paramètres de la fonction "controltransfert" vu que vous avez abouti à le faire???

Merci beaucoup

Bonjour,

J'ai finalement réussi à faire marcher le transfert avec les fonctions suivantes :
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 // fait une seule requete de base private void baseRequest(){ LibUsb.clearHalt(handle, (byte)0x0); LibUsb.clearHalt(handle, (byte)0x81); int result; int count = 0; bufferData = ByteBuffer.allocateDirect(32); Transfer interruptTransfer = LibUsb.allocTransfer(0); LibUsb.fillInterruptTransfer(interruptTransfer , handle, ENDPOINT_ID, bufferData,receiveBaseRequest, null, 200L); //bufferData.rewind(); LibUsb.unlockEvents(contexte); LibUsb.submitTransfer(interruptTransfer); bufferControl= ByteBuffer.allocateDirect(16); bufferControl.put((byte)0x00); bufferControl.put((byte)0x00); bufferControl.put((byte)0x00); bufferControl.put((byte)0x00); bufferControl.put((byte)0x00); bufferControl.put((byte)0x00); bufferControl.put((byte)0x00); bufferControl.put((byte)0x00); // now the data bufferControl.put((byte)0xa1); bufferControl.put((byte)0x00); bufferControl.put((byte)0x00); bufferControl.put((byte)0x20); bufferControl.put((byte)0xa1); bufferControl.put((byte)0x00); bufferControl.put((byte)0x00); bufferControl.put((byte)0x20); bufferControl.rewind(); Transfer controlTransfer = LibUsb.allocTransfer(0); //bufferControl.rewind(); LibUsb.fillControlSetup(bufferControl,(byte)0x21,(byte)0x09,( short)0x0200,(short)0x0000,(short)0x08); LibUsb.fillControlTransfer(controlTransfer, handle, bufferControl,sendBaseRequest, null, 200L); //bufferControl.rewind(); controlTransfer.setEndpoint((byte)0x00); display(byteBuffer2String(controlTransfer.buffer())); result = LibUsb.submitTransfer(controlTransfer); // TODO : voir pour free les transferts } final TransferCallback receiveBaseRequest = new TransferCallback() { @Override public void processTransfer(Transfer transfer) { display(transfer.actualLength() + " bytes received !!!! "); System.out.println("baseRequest " + countRequest + " : " + byteBuffer2String(transfer.buffer())); transfer.buffer().rewind(); if (countRequest==0){ countRequest++; baseBuffer1=transfer.buffer().duplicate(); } else if (countRequest==1){ countRequest=0; baseBuffer2=transfer.buffer().duplicate(); } lock=false; } }; final TransferCallback sendBaseRequest = new TransferCallback() { @Override public void processTransfer(Transfer transfer) { display("send base request to thermometer"); // write(handle, CONNECT_BODY, bodySent); // LibUsb.freeTransfer(transfer); } };
Je ne suis pas un expert en USB mais voila ce que je peux vous dire sur le fonctionnement :
- Le ENDPOINT de contrôle est toujours accessible en Usb sur l'adresse 0x21 : c'est par cet ENDPOINT que transite par défaut les commandes USB : l'ordinateur est toujours Maître en Usb et le device toujours esclave, ce qui veut dire que l'esclave ne renverra jamais rien sans que le maître l'ordonne : c'est toujours à l'ordinateur de demander des choses et après le device sert de l'information.
- Ensuite pour la DATA, comme vous je n'avais qu'un seul EndPoint dans mon cas le 0x81.
- La fonction BaseRequest qui effectue l'échange va d'abord allouer le buffer pour accueillir la Data et la soumettre dans in InterruptTransfer sur le DATA ENDPOINT : concrètement le Driver alloue de la mémoire et se prépare à recevoir des données envoyées par le device. Notez également l'argument "receiveBaseRequest" de la fonction InterruptTransfer : il s'agit de la fonction de callBack qui sera appelée lors de la réception d'information. Nous y reviendrons ensuite.
- Ensuite le control Transfer : toujours sur le ENDPOINT 0x21, pour le reste cela dépend du device que vous avez : dans tous les cas cela définit la commande qui est envoyé. ET ATTENTION : l'ordre est important : toujours faire le fillControlSetup avant le fillControlTransfer ! Ensuite le contrôle est soumis.
- Le device reçoit la commande et renvoie les données sur le ENDPOINT DATA. C'est à ce moment que la fonction de callback receiveBaseRequest est appelée : dans mon cas la logique est spécifique au besoin du driver mais en tout cas c'est en loggant qu'elle a bien été appelée qu'on sait si le device a bien répondu et transféré de la donnée. Ensuite la donnée est disponible dans le bufferData donnée à l'InterruptTransfer.

J’espère que ce message vous sera utile,

Cdt,

15/08/2017, 11h31
sofiasafia

Merci beaucoup sween D pour ton aide :D,

Je vais essayer ce code et j'espère qu'il va marcher.

Cdt,