Discussion :

[Saita]

Bonjour,
J'ai un code actuellement qui marche bien mais je pense que se n'est pas "ce qu'il faudrait faire".
Je m'explique : j'ai ma classe qui me permet d'envoyer un tableau de byte sur le port série, et d'écouter la réponse correspondante renvoyée aussi sur le port série immédiatement après la réception du tableau de byte envoyé.

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
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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
package com.atosworldline.rd.wodapa;

import javax.comm.*;
import com.sun.comm.Win32Driver;
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.util.*;


public class BasicReadWrite {

	/*
	 *  Cette classe permet de tester les ports séries disponibles
	 * en les listant puis en créant un stream d'entrée et de sortie
	 * 
	 * // TODO Implémenter un listener pour enlever le sleep
	 * 
	 */
	*/ 
	     /* variables locales */
	static char[] byte2={0x3E,0x33,0x00,0x00,0x02,0x06,0x00,0x09};

	static Enumeration	      portList;
	static CommPortIdentifier portId; //identifiant du port
	static char[] beep={0x3E,0x36, 0x00, 0x00, 0x06, 0x03, 0x00, 0x10, 0x00, 0x01, 0x32, 0x2E};
	static SerialPort	      serialPort; //le port série
	static OutputStream       outputStream;  //flux d'écriture du port
	static InputStream		      inputStream;//flux de lecture du port
	static boolean	      outputBufferEmptyFlag = false;
	private SerialPort sPort; 



	/*
			 Constructeur de la classe 
		 qui prend en paramètre le port série à utiliser.
			 Dans un premier temps on liste les ports disponibles sur le pc
	 */
	public BasicReadWrite ()
	{
		//initialisation du driver
		Win32Driver w32Driver = new Win32Driver();
		w32Driver.initialize(); 
	}//fin constructeur

	public static void listePortsDispo()
	{

		System.err.println("recherche...");
		Enumeration<CommPortIdentifier> portList=CommPortIdentifier.getPortIdentifiers();
		if (portList==null)
		{
			System.err.println("Aucun port de communication détecté");
			return;
		}
		while (portList.hasMoreElements())
		{
			portId=(CommPortIdentifier)portList.nextElement();
			System.out.println("* "+portId.getName());
		}
	}
	
	public void initialisation(String port){
		//récupération de l'identifiant du port

			try {
				portId = CommPortIdentifier.getPortIdentifier(port);
			} catch (NoSuchPortException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}

		/*ouverture du port avec le nom de l'application qui demande le port
		 * le délai d'attente pour l'obtention du port en millisecondes
		 */

		try {
			System.out.println("Ouverture du port "+port);
			sPort = (SerialPort) portId.open("UtilisationFlux", 10000);
		} catch (PortInUseException e) {
		}
		//règle les paramètres de la connexion
		/*
		 *  le contrôle de flux 		 * le débit de la connexion (en Bauds)		 * le nombre de bits de données
		 * le ou les bits stop		 * la présence d'un bit de parité
		 * */
		try{
			System.out.println("Chargement des paramètres");
			sPort.setRTS(false);
			sPort.setDTR(false);
			sPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
			sPort.setSerialPortParams(115200, SerialPort.DATABITS_8, SerialPort.STOPBITS_2, SerialPort.PARITY_NONE);
		}catch (UnsupportedCommOperationException ex){
			//gestion de l'exception
		}

	}

	public int communique(char[]apdu,byte[]reponse) {
		//pour lire et écrire avec des streams:
		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
			Thread.sleep(200); 
			DataInputStream input=new DataInputStream(sPort.getInputStream());				
			if (input.available()>0){
				int readByte=input.read(reponse);
				System.out.println("Lecture de "+readByte+" byte");
				output.flush();
				input.close();
				output.close();
				return readByte;
			}
			else {
				System.out.println("Pas de lecture : "+input.available()+" données..");
				output.flush();
				input.close();
				output.close();
				return 0;
			}

		}
		catch (Exception e)
		{
			e.printStackTrace();
			System.out.println("Erreur de communication !");
			return 0;
		}
	}
	/**
	 * Méthode de fermeture des flux et port.
	 */
	public void close(){

		sPort.close();
	}
	
	  // table to convert a nibble to a hex char.
	  private static char[] hexChar = {
	    '0', '1', '2', '3',
	    '4', '5', '6', '7',
	    '8', '9', 'a', 'b',
	    'c', 'd', 'e', 'f'};
	  public static String hex2String(byte[] b) {
		    StringBuffer sb = new StringBuffer(b.length * 2);
		    for (int i = 0; i < b.length; i++) {
		      // look up high nibble char
		      sb.append(hexChar[(b[i] & 0xf0) >>> 4]);

		      // look up low nibble char
		      sb.append(hexChar[b[i] & 0x0f]);
		    }
		    return sb.toString().toUpperCase();
		  }
	  
	  public static String hex2String(byte b) {
		    StringBuffer sb = new StringBuffer(2);
		      // look up high nibble char
		      sb.append(hexChar[(b & 0xf0) >>> 4]);

		      // look up low nibble char
		      sb.append(hexChar[b & 0x0f]);

		    return sb.toString().toUpperCase();
		  }
	  
		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();
		}
	  
	/*
	Methode main qui permet de tester notre classe de teste en ouvrant une connexion sur le port COM1.
	 */
	public static void main(String args[])
	{

		System.out.println("listage des ports série disponibles:");
		listePortsDispo();
		
		byte[] reponse = new byte[256];
		byte []reponse2;
		BasicReadWrite test=new BasicReadWrite ();
		System.out.println("Initialisation");
		test.initialisation("COM1");
		int readByte = 0;
		readByte=test.communique(beep, reponse);		
		reponse2 = new byte[readByte];
		for (int i=0;i<readByte;i++){
			reponse2[i]=reponse[i];
		}
		if (readByte!=0){			
			System.out.println("Reponse beep: "+ hex2String(reponse2));
		}
		
		readByte=test.communique(byte2, reponse);		
		reponse2 = new byte[readByte];
		for (int i=0;i<readByte;i++){
			reponse2[i]=reponse[i];
		}
		if (readByte!=0){			
			System.out.println("Reponse byte2: "+ hex2String(reponse2));
		}
		

        
		System.out.println("Fermeture");
		test.close();

	}//fin du main

}//fin de la classe

Le but du jeu étant d'enlever ce sleep car j'ai constaté qu'en fonction du nombre de miliseconde (en dessous de 200), je n'avais pas toute la réponse attendue voir pas de réponse (alors que je sais qu'une réponse est automatiquement émise après reception).
Mais j'avoue que je n'ai pas tout compris sur les listener...
J'ai regardé pas mal de tuto dont beaucoup parlent de swing et d'évènements tels qu'un clic, hors moi ici ce n'est pas ça mais la reception de qqch sur le port série.
J'ai aussi vu ce tuto qui devrait répondre à ma question http://christophej.developpez.com/tu...javacomm/#L3.2 mais je n'arrive pas à voir comment modifier ce code pour l'adapter à mon cas..(et puis un sleep est aussi utilisé ?...)
Merci pour votre aide,
Saita

[merill]

[CODE]
DataInputStream input=new DataInputStream(sPort.getInputStream());
if (input.available()>0){
int readByte=input.read(reponse);
System.out.println("Lecture de "+readByte+" byte");
output.flush();
input.close();
output.close();
return readByte;
}
else {
System.out.println("Pas de lecture : "+input.available()+" données..");
output.flush();
input.close();
output.close();
return 0;
}

En fait, tu veut tout lire en une fois en espérant que tu auras reçu ta réponse en moins de 200ms, tout en priant pour que cela ne dépasse pas le tampon?

Si oui: au lieu d'utiliser un if pour un test non-bloquant, utilise directement le int read(byte[] b), qui est un appel bloquant.
Il te met int byte dans ton tableau, et tu répète cela jusqu'à que tu veuille arrêter d'écouter ton port série.

Code :

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

1
2
3
4
5
6
7
8
 
boolean pasfinit = true;
do{
   int readByte=input.read(reponse);
   //faire des choses avec, en pensant bien que l'on a pas tout le message
   // et peut-être ausi un bout du message suivant.
   //et que ce traitement ne doit pas être trop long ou alors fait dans un autre thread.
while(pasFinit)

Après, pour les traitements sur les données reçu, je te laisse te débrouiller.

[rolfone]

non si j'ai bien compris il veut passé sont application qui fait une attente active dans un thread a une attente évènementiel (liberation du CPU)

je viens de regardé l'exemple que tu a donné qui correspond exactement à ce que tu veut peut tu dire ce qui te bloque?

[Saita]

Oui rolfone c'est ça. Je sais que j'ai presque la réponse sous les yeux mais je dois avoir un soucis de compréhension..
Tout d'abord, à quel moment lui dit-on "je veux que tu écoutes sur le port série" ? Ensuite, je n'ai pas compris cette commande :

Code :

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

serialPort.notifyOnDataAvailable(true);

ainsi que l'utilité de la méthode run.
Aussi, je ne vois pas comment récupérer ce que j'ai écouté, car le seul endroit où je peux le récupérer (si j'ai bien compris) c'est dans la méthode serialEvent et cette méthode ne peux rien renvoyer.
Enfin, le main reste un grand mystère car la seule méthode appelée est start et je ne sais pas ce qu'elle fait.
Voilà ! Merci

[rolfone]

Alors je vais te dire comment je comprend le programme.

alors quand je regarde le constructeur on passe une String en paramètre qui représente le port à utiliser. On réserve la ressource puis on capture le flux (pour pouvoir lire) et pour finir on paramètre ce port vitesse forme des trame ... (bizarre on prend le flux avant de le paramétrer?)

toujours dans le constructeur on ajoute notre listener (celui qui vas faire l'action sur un évènement)

Code :

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

serialPort.addEventListener(this);

et on specifie a notre port de généré un evenement quand celui si a des valeur valide

Code :

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

serialPort.notifyOnDataAvailable(true);

donc quand on en est la nous avons la source de l'évènement et qui vas le capturer

c'est donc dans notre SerialPortEventListener que l'on vas faire le traitement

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
	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 :
			case SerialPortEvent.OE :
			case SerialPortEvent.FE :
			case SerialPortEvent.PE :
			case SerialPortEvent.CD :
			case SerialPortEvent.CTS :
			case SerialPortEvent.DSR :
			case SerialPortEvent.RI :
			case SerialPortEvent.OUTPUT_BUFFER_EMPTY :
				break;
			case SerialPortEvent.DATA_AVAILABLE :
				String codeBarre = new String(); 
				try {
					//lecture du buffer et affichage
					codeBarre = (String) fluxLecture.readLine();
					System.out.println(codeBarre);
				} catch (IOException e) {
				}
				break;
		}
	}

c'est ici que la lecture du port est effectué (je ne comprend pas très bien ici je me serais plutôt attendu à la récupération d'un char que d'une String)
ou dans le cas ou nous avons des DATA_AVAILABLE on vas les lire dans tout les autre cas on ne fait rien (les autre code sons dans la javadoc).

c'est tout ce que tu a besoin dans ton cas.

après pour la récupération de ton résultat selon ce que tu doit faire tu a différente technique.

pour la méthode main bon la je doit avoué c'est pas super simple a comprendre comme ça.

si tu regarde dans la déclaration de la class tu a extends Thread
c'est juste la pour crée du traitement en attendant la lecture (si je ne me trompe pas mais normalement c'est ça )

pour résume donc tu a besoin d'un class qui implement SerialPortEventListener

et d'un SerialPort et il faut que tu ajoute comme listener à ton SerialPort le SerialPortEventListener.

test déjà si comme cela tu arrive a récupéré la valeur un Systeme.out.println();

dit moi si je ne suis pas clair sur un point (ou plusieurs)

[Saita]

En fait j'avais déjà testé ça :

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
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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
package com.atosworldline.rd.wodapa;
 
import javax.comm.*;
 
import com.sun.comm.Win32Driver;
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.util.*;
 
public class ModeEvenement extends Thread implements SerialPortEventListener {
 
	private CommPortIdentifier portId;
	private static SerialPort serialPort;
	private BufferedReader fluxLecture;
	private boolean running;
 
	static char[] sCREnable={0x3E, 0x33, 0x00, 0x00, 0x04, 0x01, 0x00, 0x05, 0x00, 0x0D};
	static char[] checkForCard={0x3E, 0x33, 0x00, 0x00, 0x02, 0x04, 0x00, 0x0B};
	static char[] powerOn={0x3E, 0x33, 0x00, 0x00, 0x02, 0x02, 0x00, 0x0D};
	static char[] apduGetChallenge={0x00,0x84,0x00,0x00,0x08};
//		 static byte[] exchangeAPDU[]={0x3E, 0x33, 0x00, 0x00, 0x09, 0x05, 0x00, 0x00,0x84,0x00,0x00,0x08, 0x8D}; // 4 byte APDU
	//   static byte[] exchangeAPDU[]={0x3E, 0x33, 0x00, 0x00, 0x0F, 0x05, 0x00, 0x00, 0xA4, 0x04, 0x00, 0x07, 0xA0, 0x00, 0x00, 0x00, 0x03, 0x10, 0x10, 0x00, 0x03}; // 13 byte APDU
	static char[] exchangeAPDU={0x3E, 0x33, 0x00, 0x00, 0x16, 0x05, 0x00, 0x00, 0xA4, 0x04, 0x00, 0x07, 0x31, 0x50, 0x41, 0x59, 0x2E, 0x53, 0x59, 0x53, 0x2E, 0x44, 0x44, 0x46, 0x30, 0x31, 0x00, 0xDE}; // 20 byte APDU
	static char[] powerOff={0x3E, 0x33, 0x00, 0x00, 0x02, 0x03, 0x00, 0x0C};
	static char[] disableSCR={0x3E,0x33,0x00,0x00,0x02,0x06,0x00,0x09};
 
	/**
         * Constructeur qui récupère l'identifiant du port et lance l'ouverture.
         */
	public ModeEvenement(String port) {
		//initialisation du driver
		System.out.println("initialisation du driver");
		Win32Driver w32Driver = new Win32Driver();
		w32Driver.initialize();
		//récupération de l'identifiant du port
		try {
			System.out.println("récupération de l'identifiant du port");
			portId = CommPortIdentifier.getPortIdentifier(port);
		} catch (NoSuchPortException e) {
		}
 
		//ouverture du port
		try {
			System.out.println("ouverture du port");
			serialPort = (SerialPort) portId.open("ModeEvenement", 2000);
		} catch (PortInUseException e) {
		}
		//récupération du flux
		try {
			System.out.println("récupération du flux");
			fluxLecture =
				new BufferedReader(
					new InputStreamReader(serialPort.getInputStream()));
		} catch (IOException e) {
		}
		//ajout du listener
		try {
			System.out.println("ajout du listener");
			serialPort.addEventListener(this);
		} catch (TooManyListenersException e) {
		}
		//paramétrage du port
		serialPort.notifyOnDataAvailable(true);
		try {
			serialPort.setRTS(false);
			serialPort.setDTR(false);
			serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
			serialPort.setSerialPortParams(115200, SerialPort.DATABITS_8, SerialPort.STOPBITS_2, SerialPort.PARITY_NONE);
 
		} catch (UnsupportedCommOperationException e) {
		}
		System.out.println("port ouvert, attente de lecture");
	}
	public void run() {
		running = true;
		while (running) {
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
			}
		}
		//fermeture du flux et port
		try {
			fluxLecture.close();
		} catch (IOException e) {
		}
		serialPort.close();
	}
	/**
         * Méthode de gestion des événements.
         */
	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 :
				String retour = new String(); 
				try {
					//lecture du buffer et affichage
					retour = (String) fluxLecture.readLine();
					System.out.println(retour);
				} catch (IOException e) {
				}
				break;
		}
	}
 
 
	  // table to convert a nibble to a hex char.
	  private static char[] hexChar = {
	    '0', '1', '2', '3',
	    '4', '5', '6', '7',
	    '8', '9', 'a', 'b',
	    'c', 'd', 'e', 'f'};
	  public static String hex2String(byte[] b) {
		    StringBuffer sb = new StringBuffer(b.length * 2);
		    for (int i = 0; i < b.length; i++) {
		      // look up high nibble char
		      sb.append(hexChar[(b[i] & 0xf0) >>> 4]);
 
		      // look up low nibble char
		      sb.append(hexChar[b[i] & 0x0f]);
		    }
		    return sb.toString().toUpperCase();
		  }
 
	  public static String hex2String(byte b) {
		    StringBuffer sb = new StringBuffer(2);
		      // look up high nibble char
		      sb.append(hexChar[(b & 0xf0) >>> 4]);
 
		      // look up low nibble char
		      sb.append(hexChar[b & 0x0f]);
 
		    return sb.toString().toUpperCase();
		  }
 
		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();
		}
 
 
	/**
         * Permet l'arrêt du thread
         */
	public void stopThread() {
		running = false;
	}
	/**
         * Méthode principale de l'exemple.
         */
	public static void main(String[] args) {
		//Récuperation du port en argument
		String port = "COM1";
		//lancement de l'appli
		ModeEvenement modeEve=new ModeEvenement(port);
		modeEve.start();
		SimpleWrite beep=new SimpleWrite();
		beep.ecrit(serialPort);
		//"interface utilisateur"
//		System.out.println("taper q pour quitter");
//		//construction flux lecture
//		BufferedReader clavier =
//			new BufferedReader(new InputStreamReader(System.in));
//		//lecture sur le flux entrée.
//		try {
//			String lu = clavier.readLine();
//			while (!lu.equals("q")) {
//			}
//		} catch (IOException e) {
//		}
		modeEve.stopThread();
	}
}

Mais ça me retourne Output buffer is empty. Alors que je sais que j'ai forcément une réponse... Donc je comprend pas ce qui cloche (le programme se termine)

[rolfone]

heu je viens juste de commencé a lire ton code et ne rien mettre dans les catch surtout quand tu test c'est pas bien

un

Code :

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

System.err.println(e);

ça coute rien

en plus c'est con tu trace bien ton code

[rolfone]

test comme cela

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
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
package com.atosworldline.rd.wodapa;
 
import javax.comm.*;
 
import com.sun.comm.Win32Driver;
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.util.*;
 
public class ModeEvenement extends Thread implements SerialPortEventListener {
 
	private CommPortIdentifier portId;
	private SerialPort serialPort;
	private BufferedReader fluxLecture;
	private boolean running;
 
	static char[] sCREnable={0x3E, 0x33, 0x00, 0x00, 0x04, 0x01, 0x00, 0x05, 0x00, 0x0D};
	static char[] checkForCard={0x3E, 0x33, 0x00, 0x00, 0x02, 0x04, 0x00, 0x0B};
	static char[] powerOn={0x3E, 0x33, 0x00, 0x00, 0x02, 0x02, 0x00, 0x0D};
	static char[] apduGetChallenge={0x00,0x84,0x00,0x00,0x08};
	static char[] exchangeAPDU={0x3E, 0x33, 0x00, 0x00, 0x16, 0x05, 0x00, 0x00, 0xA4, 0x04, 0x00, 0x07, 0x31, 0x50, 0x41, 0x59, 0x2E, 0x53, 0x59, 0x53, 0x2E, 0x44, 0x44, 0x46, 0x30, 0x31, 0x00, 0xDE}; // 20 byte APDU
	static char[] powerOff={0x3E, 0x33, 0x00, 0x00, 0x02, 0x03, 0x00, 0x0C};
	static char[] disableSCR={0x3E,0x33,0x00,0x00,0x02,0x06,0x00,0x09};
 
	/**
         * Constructeur qui récupère l'identifiant du port et lance l'ouverture.
         */
	public ModeEvenement(String port) {
		//initialisation du driver
		System.out.println("initialisation du driver");
		Win32Driver w32Driver = new Win32Driver();
		w32Driver.initialize();
		//récupération de l'identifiant du port
		try {
			System.out.println("récupération de l'identifiant du port");
			portId = CommPortIdentifier.getPortIdentifier(port);
		} catch (NoSuchPortException e) {
		}
 
		//ouverture du port
		try {
			System.out.println("ouverture du port");
			serialPort = (SerialPort) portId.open("ModeEvenement", 2000);
		} catch (PortInUseException e) {
		}
		//récupération du flux
		try {
			System.out.println("récupération du flux");
			fluxLecture =
				new BufferedReader(
					new InputStreamReader(serialPort.getInputStream()));
		} catch (IOException e) {
		}
		//ajout du listener
		try {
			System.out.println("ajout du listener");
			serialPort.addEventListener(this);
		} catch (TooManyListenersException e) {
		}
		//paramétrage du port
		serialPort.notifyOnDataAvailable(true);
		try {
			serialPort.setRTS(false);
			serialPort.setDTR(false);
			serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
			serialPort.setSerialPortParams(115200, SerialPort.DATABITS_8, SerialPort.STOPBITS_2, SerialPort.PARITY_NONE);
 
		} catch (UnsupportedCommOperationException e) {
		}
		System.out.println("port ouvert, attente de lecture");
	}
 
	/**
         * Méthode de gestion des événements.
         */
	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.");
				String retour = new String(); 
				try {
					//lecture du buffer et affichage
					retour = (String) fluxLecture.readLine();
					System.out.println(retour);
				} catch (IOException e) {
				}
				break;
		}
	}
 
	/**
         * Permet l'arrêt du thread
         */
	public void stopThread() {
		running = false;
	}
	// RolfOne: le thraed qui attend
	public void run() {
		SimpleWrite beep=new SimpleWrite();
 
		running = true;
		while (running) {
			//Rolfone on ecrit sur notre port
			beep.ecrit(serialPort);
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
			}
		}
		//fermeture du flux et port
		try {
			fluxLecture.close();
		} catch (IOException e) {
		}
		serialPort.close();
	}
	/**
         * Méthode principale de l'exemple.
         */
	public static void main(String[] args) {
		//Récuperation du port en argument
		String port = "COM1";
		//lancement de l'appli
		ModeEvenement modeEve=new ModeEvenement(port);
		modeEve.start();
 
		//"interface utilisateur"
		System.out.println("taper q pour quitter");
		//construction flux lecture
		BufferedReader clavier =
			new BufferedReader(new InputStreamReader(System.in));
		//lecture sur le flux entrée.
		try {
			String lu = clavier.readLine();
			while (!lu.equals("q")) {
			}
		} catch (IOException e) {
		}
		modeEve.stopThread();
	}
}

et ajoute ce qu'il manque dans les try/catch

et tu peut me faire voir ton output stp

[Saita]

Dslée j'ai fait un bête copié-collé du code d'origine pour ça..
Mais c'est vrai aussi que la plupart du temps je ne sais pas trop quoi mettre dans mes catch.. Je me contente de les générer via eclipse et je laisse ce qui est mit par défaut... Comment pourrais-je m'améliorer là-dessus au passage ?
Si tu as des conseils..

J'ai testé ton code (j'y avait pensé à le mettre dans le run je suis contente ça veut dire que je pense bien lol) mais pas beaucoup mieux :

initialisation du driver
récupération de l'identifiant du port
ouverture du port
récupération du flux
ajout du listener
port ouvert, attente de lecture
taper q pour quitter
Writing ">6*ya des caractères inconnus que je ne peux pas reproduire*2." to COM1
Output buffer is empty.
DATA_AVAILABLE.

[rolfone]

je voulais faire un test mais impossible de trouver ou télécharger l'API a tu l'url stp

[Saita]

l'url de quoi ? Dslée peux-tu préciser de quelle api tu veux parler ?

[rolfone]

donc tu a bien envoyer ton message si je ne me trompe pas c'est cette ligne de ton log

Writing ">6*ya des caractères inconnus que je ne peux pas reproduire*2." to COM1

il trouve le

Output buffer is empty.

ce qui veut dire que ton message est bien partie

et après il réceptionne bien un message

DATA_AVAILABLE.

si tu change ca

Code :

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

1
2
3
4
5
6
7
8
9
10
11
            case SerialPortEvent.DATA_AVAILABLE:
                System.out.println("DATA_AVAILABLE.");
 
                try {
                    //lecture du buffer et affichage
                    char[] retour = new char[20];
                    int charlu = fluxLecture.read(retour);
                    System.out.println(retour);
                } catch (IOException e) {
                }
                break;

il y a bien des char qui sont lu ?

[rolfone]

je parlle de l'url de l'api que tu utilise pour lire/ecrire sur le port serie

javax.comm.*;

[Saita]

Oui il est assez dur à trouver et installer lol.
Je te le met en pièce jointe.
Je testerai ton code après mangé.
Merci pour ton aide ! A tout à l'h

[Saita]

Bon, première étape de franchie : ce code marche après qques arrangement de lecture pr le sysout.
Mais le code reste problématique : la commande que j'envoie ici est "en dur" dans la méthode run et pas moyen de mettre cette commande en argument..
Comment faire ? (Si je me suis mal exprimée dis le moi)

[rolfone]

Alors on en reviens a ce que je t'ai dit

ici la méthode run n'est utiliser que pour attendre et envoyer le message


donc en fait la tu peut supprimer
extends Thread dans la déclaration de la class
la méthode run()
et la méthode main()

et tu peut utilisé t'a class

par contre il te faudra peut être faire 2 3 modifications

dans cette exemple le SerialPort est initialisé dans la class ce qui n'est pas une des fonction de la class (du moins d'après moi) je vais expliqué pourquoi je dit ça.

dans l'exemple la class est aussi le programme principale or dans ton cas ce n'est pas le listener qui a besoin du SerialPort mais bien ton programme principale.

donc voila comment je voie la chose :

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
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
 
import com.sun.comm.Win32Driver;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.TooManyListenersException;
import javax.comm.CommPortIdentifier;
import javax.comm.NoSuchPortException;
import javax.comm.PortInUseException;
import javax.comm.SerialPort;
import javax.comm.SerialPortEvent;
import javax.comm.SerialPortEventListener;
import javax.comm.UnsupportedCommOperationException;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
 
public class ProgrammePrincipal extends JFrame {
 
    private JTextField sendMessage = new JTextField("", 25);
    private JLabel receiveMessage = new JLabel("");
    private JButton send = new JButton("Send");
    private SerialPort serialPort;
    private CommPortIdentifier portId;
    private BufferedReader fluxLecture;
    private PrintWriter fluxecriture;
 
    public ProgrammePrincipal() {
        this.setLayout(new FlowLayout());
        this.add(sendMessage);
        this.add(send);
        this.add(receiveMessage);
 
        this.initPort("COM50");
        this.send.addActionListener(new ActionListener() {
 
            public void actionPerformed(ActionEvent e) {
                ecrire();
            }
        });
 
        this.pack();
    }
 
    private void initPort(String port) {
        //initialisation du driver
        System.out.println("initialisation du driver");
        Win32Driver w32Driver = new Win32Driver();
        w32Driver.initialize();
        //récupération de l'identifiant du port
        try {
            System.out.println("récupération de l'identifiant du port");
            portId = CommPortIdentifier.getPortIdentifier(port);
        } catch (NoSuchPortException e) {
        }
 
        //ouverture du port
        try {
            System.out.println("ouverture du port");
            serialPort = (SerialPort) portId.open("ModeEvenement", 2000);
        } catch (PortInUseException e) {
        }
        //récupération du flux
        try {
            System.out.println("récupération du flux");
            fluxLecture = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));
            fluxecriture = new PrintWriter(serialPort.getOutputStream(), true);
        } catch (IOException e) {
        }
        //ajout du listener
        try {
            System.out.println("ajout du listener");
            serialPort.addEventListener(new SerialPortEventListener() {
 
                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.");
                            //ici tu poura avoir les variable de ProgrammePrincipal
                            lire();
                            break;
                    }
                }
            });
        } catch (TooManyListenersException e) {
        }
        //paramétrage du port
        serialPort.notifyOnDataAvailable(true);
        try {
            serialPort.setRTS(false);
            serialPort.setDTR(false);
            serialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
            serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8, SerialPort.STOPBITS_2, SerialPort.PARITY_NONE);
 
        } catch (UnsupportedCommOperationException e) {
        }
        System.out.println("port ouvert, attente de lecture");
 
    }
 
    public void lire() {
        String retour = new String();
        try {
            //lecture du buffer et affichage
            retour = (String) fluxLecture.readLine();
            System.out.println(retour);
 
            receiveMessage.setText(retour);
        } catch (IOException e) {
        }
    }
 
    public void ecrire() {
        fluxecriture.print(this.sendMessage.getText());
    }
 
    public static void main(String[] args) {
        new ProgrammePrincipal().setVisible(true);
    }
}

eu bon quand je vois ce que je viens de faire je suis pas sur que cela t'aide vraiment ;(

[rolfone]

bon ça marche bien ce que je t'est donné je viens de joué avec

ProgrammePrincipal -> COM8(virtuel) ----- COM9(virtuel) ->hypertherm

et tout ce parle bien

bon par contre dit moi si c'est vraiment trop incompréhensible

[Saita]

Dslée pour l'absence, je teste ça ce matin

[Saita]

Coucou, je pense qu'on se rapproche fortement de ce que je voulais faire
Mais j'avoue ne pas tout comprendre tes explications
L'idéal pour moi se serait de n'avoir qu'une seule classe un peu comme celle-ci :

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
package com.atosworldline.rd.wodapa;
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
 
import javax.comm.SerialPort;
 
public class SendToSPort implements SendToLPP {
 
	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);
			//A modifier peut etre ajout d'un listener
			Thread.sleep(200); 
			DataInputStream input=new DataInputStream(sPort.getInputStream());				
			if (input.available()>0){
				int readByte=input.read(reponse);
				System.out.println("Lecture de "+readByte+" byte");
				byte[] reponse2=new byte[readByte];
				for (int i=0;i<readByte;i++){
					reponse2[i]=reponse[i];
				}
				output.flush();
				input.close();
				output.close();
				return reponse2;
			}
			else {
				System.out.println("Pas de lecture : "+input.available()+" données..");
				output.flush();
				input.close();
				output.close();
				return null;
			}
 
		}
		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();
	}
 
}

mais en "mode évènement".
Donc j'avoue que j'ai du mal à comprendre ce que tu as dit :

extends Thread dans la déclaration de la class
la méthode run()
et la méthode main()

et tu peut utilisé t'a class

Sinon niveau code je comprend assez bien ce que tu as fait et je pense que ça colle avec ce que je veux mais j'ai un petit soucis : tu let le listener sur le bouton "send" mais dans mon cas, je n'ai pas cette variable..
J'ai essayé en déclarant un objet de la classe send que j'ai fait (qui ne fait que envoyer) mais Eclipse me met une erreur et me demande d'implémenter "addActionListener" dans ma classe send..

[Saita]

Est-ce que je peux implémenter addActionListener dans ma classe Send et le reécrire dans ma classe principale ModeEvenement ? Dans ce cas, mon tableau de byte à envoyer sera une variable de ma classe qu'il faudra renseigner par un set ou en appelant une méthode sendCommande (ça fait beaucoup de classe et de méthode send je commence à être à court de mot commencant par send ! )