Remplacer un thread par un listener

Version imprimable

Voir 40 message(s) de cette discussion en une page

30/07/2010, 11h20
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.
30/07/2010, 11h25
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
30/07/2010, 11h32
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.
30/07/2010, 11h37
rolfone

ok c'est bon j'ai compris

peut tu faire qq'chose temps que tu n'a pas de réponse ?
30/07/2010, 11h47
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..

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:

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'

30/07/2010, 13h40
Saita

Alors ça ne marchera pas :cry:
Comme je l'ai dit le terminal me renvoi un tableau de bytes mais il ne se finit pas par \n..
30/07/2010, 13h49
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
30/07/2010, 14h52
Saita
Hmmm là j'avoue que tu me poses une colle.. Je ne sais pas trop.
Quand j'utilise cette méthode :
Code:

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 :

Citation:

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"
30/07/2010, 15h09
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 ;)
30/07/2010, 15h12
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..
30/07/2010, 15h34
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.
30/07/2010, 16h00
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 :aie: 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 :oops:
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..)
30/07/2010, 16h10
rolfone

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

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
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 ;)

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

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
 
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

30/07/2010, 16h53
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
30/07/2010, 16h54
Saita

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

Edit : si jamais une solution avec un listener apparait, je suis quand même preneuse, je pense que se serait plus "propre".
30/07/2010, 16h57
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é

Voir 40 message(s) de cette discussion en une page