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)