Discussion :

[rolfone]

Alors
c'est partie donc déjà le listener ajouter sur le bon c'est juste pour que j'ai la possibilité d'envoyer un massage et donc tester ma connexion pour être sur que mon application communique bien.

Apres la j'ai besoin de réfléchir lol pour comprendre ce que tu veut faire.

[rolfone]

peut tu me dire exactement ce que tu doit faire stp je doit avoué que je me noie la.

il me faut ton problème et environnement de basse stp. *

j'ai une application graphique qui doit lire des code barre. voila un truc comme cela

[Saita]

Je vais essayer de bien expliquer en détail
C'est assez simple : j'ai un terminal bancaire qui est branché en port série sur mon ordinateur. Je communique avec lui en lui envoyant un tableau de byte (pour lui demander de biper par exemple ou d'afficher quelquechose), et à chaque fois, il me renvoi un tableau de byte à son tour pour me dire qu'il a bien reçu et exécuter la commande ou que ça c'est mal passé.
Donc je veux envoyer ma commander, mettre un listener sur le port série pour écouter le retour du terminal pour savoir si tout s'est bien passé.
C'est exactement ce que je fais avec la classe SendToSPort que je t'ai mise un peu plus bas (à la page d'avant), mais sauf que je fais un sleep au lieu d'attendre activement la réponse du terminal.
Est-ce un peu plus clair ?
Donc pas de bouton send dans mon cas... Juste un main pour envoyer ma commande pour l'instant.

[rolfone]

ok c'est bon j'ai compris

peut tu faire qq'chose temps que tu n'a pas de réponse ?

[Saita]

Non ce n'est pas prévu. A priori il ne devrait rien se passer entre le moment où j'envoie ma commande et le moment où je reçois la réponse. C'est pour ça qu'au départ je ne voulais pas me prendre la tête avec un listener. Pas de raison à priori pour. Seulement il y a un temps de latence (de l'ordre de 200 millisecondes d'après mes tests) entre le moment où j'envoie ma commande et où je reçois la réponse..

[rolfone]

dommage bon au moins tu sais faire un listener now:

si tu ne peut rien faire sans la réponse bien il faut l'attendre le listener permette de faire autre chose entre temps.

toi ta solution est bien plus simple

Code :

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

1
2
3
4
5
6
        try {
            System.out.println(fluxLecture.readLine());
            System.out.println("il y a une reponse");
        } catch (IOException ex) {
            System.err.println(ex.getMessage());
        }

ps: ça ne marche que si ta réponse ce fini par un '\n'

[Saita]

Alors ça ne marchera pas
Comme je l'ai dit le terminal me renvoi un tableau de bytes mais il ne se finit pas par \n..

[rolfone]

tu a quoi comme code de fin ?

il y a sois un tableau sans taille determiner dans ce cas tu doit avoir un séquence de fin.

ou alors ton tableau a toujours la même taille

[Saita]

Hmmm là j'avoue que tu me poses une colle.. Je ne sais pas trop.
Quand j'utilise cette méthode :

Code :

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

1
2
3
			DataInputStream input=new DataInputStream(sPort.getInputStream());				
			if (input.available()>0){
				int readByte=input.read(reponse);

le readByte correspond au nombre de byte renvoyé.
Je vais voir si il y a plus d'info sur la façon dont cette méthode fait ça

Edit :

Reads some number of bytes from the contained input stream and stores them into the buffer array b. The number of bytes actually read is returned as an integer. This method blocks until input data is available, end of file is detected, or an exception is thrown.

Pas très clair... en gros si je traduis bien "tant que des données peuvent être lues ou que la fin d'un fichier soit rencontrée"

[rolfone]

oui c'est exactement ça temps qu'il y en à je lie.

tu a pas une doc ou un dev guide qui te donne les message de retour?

par exemple retourne
0x81 4A 7F => erreur de request
0x81 4A 8A => erreur de lecture

dans ce cas la tu sait qu'il faut lire 3 byte.

sinon ce que tu peut faire c'est lire en continue et provoqué les massage d'erreur pour cherché si les trames sont toujours de même longueur ca ce voit vite si il y a un code de fin c'est un peut moins facile a voir mais ca ce trouve.

le mieux étant de trouvé la doc

[Saita]

Oui j'ai la doc associée mais le soucis est que ce n'est pas fixe.
En fonction de la commande que je passe la longueur varie.
Penses-tu que je devrais rester avec mon sleep ? Ca semble plus simple et ça marche..

[rolfone]

le problème du sleep dans ce cas c'est que sait une erreur de conception

quand tu test sa dure 200ms tu mette un câble 30cm plus long un connecteur merdique ça mette 201ms et la ton programme ne marche plus.

c'est vraiment un problème qu'il faut réglé.

si la doc est un pdf que tu peut communiqué ou du moins la partie port COM je peut regardé si ça m'inspire.

si ce n'est pas un truc classique ta documentation doit forcement indiqué et expliqué le protocole de communication.

[Saita]

Je n'ai pas le droit de te communiquer ces infos dslée
Mais je pense que j'ai tous les éléments dont j'ai besoin.
Et puis, avec le listener, je pense que c'était presque ça, c'est peut etre juste que j'ai un peu de mal pour implémenter et adapter à mon cas.
En gros, pour chaque commande que j'envoie, je pourrais connaitre le nombre de bytes que je suis censée recevoir mais celui-ci change en fonction de la commande et je voudrais que ma classe soit générale.
Je suis convaincue que c'est possible car le read comme je te l'ai indiqué me renvoie bien le bon nombre de byte reçu, donc c'est que c'est possible qu'une méthode le sache sans que je lui indique à chaque fois..
Dslée je suis pas très douée avec Java des fois
Le gros soucis que j'avais avec le listener dans l'aide que tu m'avais fourni, c'était savoir sur quelle classe "l'ajouter"..
Merci encore de m'aider c'est super sympa (c'est bien utile quand nos tuteurs et autres sont trop occupés pour nous répondre..)

[rolfone]

j'ai une solution qui viens de me sauté dessus à l'instant je reprend ta class dans 5 minutes je te poste ça.

[rolfone]

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
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
package com.atosworldline.rd.wodapa;
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.util.logging.Level;
import java.util.logging.Logger;
 
import javax.comm.SerialPort;
import javax.comm.SerialPortEvent;
import javax.comm.SerialPortEventListener;
 
public class SendToSPort implements SerialPortEventListener, , SendToLPP  {
 
    private byte[] reponse;
    private int reponceLenght;
    SerialPort sPort;
 
    public void setSPort(SerialPort port) {
        sPort = port;
        try {
            this.sPort.addEventListener(this);
        } catch (TooManyListenersException ex) {
            System.err.println("[TooManyListenersException] " + ex.getMessage());
        }
    }
 
    public byte[] send(char[] apdu) {
        //pour lire et écrire avec des streams:
        reponse = new byte[256];
        reponceLenght = 0;
        try {
            DataOutputStream output = new DataOutputStream(sPort.getOutputStream());
            //Teste de lecture/ecriture sur le port série
            System.out.println("Ecriture");
            byte[] apdu2 = toByteArray(apdu);
            output.write(apdu2);
            //A modifier peut etre ajout d'un listener
            while (reponceLenght == 0) {
                //la reponce n'est toujours pas arriver
                try {
                    //j'attend donc un peut
                    Thread.sleep(50);
                } catch (InterruptedException ex) {
                    System.err.println("[InterruptedException] " + ex.getMessage());
                }
            }
            //ma reponce est arrivé
            byte[] out = new byte[reponceLenght];
 
            // on copie notre reponce dans un tableau de bonne longueur
            for (int i = 0; i < reponceLenght; i++) {
                out[i] = reponse[i];
            }
 
            return out;
 
            // pas top de catch Exception il vaut mieux catch plus finement je trouve
        } catch (IOException ex){
            System.err.println(ex.getMessage());
        }
 
        return null;
    }
 
    public void serialEvent(SerialPortEvent event) {
        //gestion des événements sur le port :
        //on ne fait rien sauf quand les données sont disponibles
        switch (event.getEventType()) {
            case SerialPortEvent.BI:
                System.out.println("Break interrupt.");
                break;
            case SerialPortEvent.OE:
                System.out.println("Overrun error.");
                break;
            case SerialPortEvent.FE:
                System.out.println("Framing error.");
                break;
            case SerialPortEvent.PE:
                System.out.println("Parity error.");
                break;
            case SerialPortEvent.CD:
                System.out.println("Carrier detect.");
                break;
            case SerialPortEvent.CTS:
                System.out.println("Clear to send.");
                break;
            case SerialPortEvent.DSR:
                System.out.println("Data set ready.");
                break;
            case SerialPortEvent.RI:
                System.out.println("Ring indicator.");
                break;
            case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
                System.out.println("Output buffer is empty.");
                break;
            case SerialPortEvent.DATA_AVAILABLE:
                System.out.println("DATA_AVAILABLE.");
                try {
                    // ici tu est sur d'avoir un message complet
                    DataInputStream input = new DataInputStream(sPort.getInputStream());
                    reponceLenght = input.read(reponse);
                } catch (IOException ex) {
                    Logger.getLogger(SendToSPort.class.getName()).log(Level.SEVERE, null, ex);
                }
                break;
        }
    }
 
    public static byte[] toByteArray(char[] array) {
        return toByteArray(array, Charset.defaultCharset());
    }
 
    public static byte[] toByteArray(char[] array, Charset charset) {
        CharBuffer cbuf = CharBuffer.wrap(array);
        ByteBuffer bbuf = charset.encode(cbuf);
        return bbuf.array();
    }
}

bon il reste toujours le problème si ta réponse fait plus de 256 byte

par contre je me pose une question comment serial port fait pour savoir que "DATA_AVAILABLE" ? il doit y avoir un contrôle qq par.

bon c'est plus propre même si peut mieux faire

[Saita]

Quelle serait la différence entre ton code, et celui-ci sans listener ? =>

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
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
 
public class Test {
 
	SerialPort sPort;
 
	public void setSPort(SerialPort port) {
		sPort = port;
	}
 
	/* (non-Javadoc)
	 * @see com.atosworldline.rd.wodapa.SendToLPP#send(char[], javax.comm.SerialPort)
	 */
	public byte[]send(char[]apdu) {
		//pour lire et écrire avec des streams:
		byte[] reponse=new byte[256];
		try {
			DataOutputStream output = new DataOutputStream(sPort.getOutputStream());
			//Teste de lecture/ecriture sur le port série
			System.out.println("Ecriture");
			byte[]apdu2=toByteArray(apdu);
			output.write(apdu2);
 
			int reponceLenght =0;
			DataInputStream input=new DataInputStream(sPort.getInputStream());
			while (reponceLenght == 0) {
				//la reponce n'est toujours pas arriver
				try {
					//j'attend donc un peut
					Thread.sleep(50);
					reponceLenght =input.read(reponse);
					System.out.println("Lecture de "+reponceLenght +" byte");
				} catch (InterruptedException ex) {
					System.err.println("[InterruptedException] " + ex.getMessage());
				}
			}
 
////			/
 
 
			byte[] reponse2=new byte[reponceLenght];
			for (int i=0;i<reponceLenght;i++){
				reponse2[i]=reponse[i];
			}
			output.flush();
			input.close();
			output.close();
			return reponse2;
		}
		catch (Exception e)
		{
			e.printStackTrace();
			System.out.println("Erreur de communication !");
			return null;
		}
	}
 
	public static byte[] toByteArray(char[] array) {
		return toByteArray(array, Charset.defaultCharset());
	}
 
	public static byte[] toByteArray(char[] array, Charset charset) {
		CharBuffer cbuf = CharBuffer.wrap(array);
		ByteBuffer bbuf = charset.encode(cbuf);
		return bbuf.array();
	}
 
}

Faudra que je vérifie pour les 256 bytes mais je ne pense pas que je puisse les atteindre. C'est pas mal quand même

[rolfone]

a bien voila ce qui me choqué dans mon code

il faut prendre le tien bien plus simple

c'est ce qui ma l'aire d'être le plus juste à faire en fait

[Saita]

lol. Oki. Je vais mettre en résolu alors...
Merci

Edit : si jamais une solution avec un listener apparait, je suis quand même preneuse, je pense que se serait plus "propre".

[rolfone]

ouai tu peut

le listener n'a pas d'utilité si tu n'est pas dans un environnement évènementiel

par exemple j'ai une apli graphique qui affiche ce que lit mon capteur la il faut que quand le capteur lit un truc paff on l'affiche

la toi tu a juste besoin d'attendre le réponse n ms pour être sur que ceci c'est bien passé