Problème réception port série

Ok merci pour vos réponses !

J'ai trouvé une solution à mon problème : Je déplace ma méthode d'écriture/lecture du port dans un thread à part mais maintenant j'ai autre problème :

Voilà mon code :

Méthode pour envoyer un caractère :

public String communique_char(char envoie) {
	ThreadEnvoi t1 = new ThreadEnvoi(envoie, outStream, bufRead);
	t1.start();
	t1.interrupt();
	while (t1.rReceived() == "" || !t1.getTimeOut()) {
	}
	return t1.rReceived();
}

Classe ThreadEnvoi contenant l'envoi du caractère et la réception de la réponse :

public class ThreadEnvoi extends Thread {
	private String caractere;
	private OutputStream outputStream;
	private String received = "";
	private BufferedReader bufRead;
	private Boolean timeOut;
 
	public ThreadEnvoi(char caractere, OutputStream outputStream,
			BufferedReader bufRead) {
		this.caractere = "" + caractere;
		this.outputStream = outputStream;
		this.bufRead = bufRead;
		this.timeOut = false;
	}
 
	public ThreadEnvoi(String caractere, OutputStream outputStream,
			BufferedReader bufRead) {
		this.caractere = caractere;
		this.outputStream = outputStream;
		this.bufRead = bufRead;
		this.timeOut = false;
	}
 
	public void run() {
		TimeOut threadTimeOut = new TimeOut(this);
		threadTimeOut.start();
		try {
			for (int i = 0; i < this.caractere.length(); i++) {
				outputStream.write(this.caractere.charAt(i));
			}
			outputStream.write('\n');
			received = bufRead.readLine().trim();
		} catch (IOException e) {
			e.printStackTrace();
		}
		this.interrupt();
 
	}
 
	public String rReceived() {
		return received;
	}
 
	public void timeElapsed() {
		this.timeOut = true;
	}
 
	public boolean getTimeOut() {
		return this.timeOut;
	}
}

Classe TimeOut contenant le temps d'attente avant de permettre à ma classe ThreadEnvoi de retourner la variable "received" :

public class TimeOut extends Thread {
 
	ThreadEnvoi envoi;
 
	public TimeOut(ThreadEnvoi envoi) {
		this.envoi = envoi;
	}
 
	public void run() {
		try {
			sleep(200); // wait of 200 ms
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.envoi.timeElapsed();
	}
}

Mon problème reste le même car si je ne choisis pas de port série et que j'essaie d'envoyer un caractère alors j'obtiens une erreur qui vient d'une ligne dans le code de ma classe ThreadEnvoi :

outputStream.write(this.caractere.charAt(i));

Et si je choisis un port alors là j'ai une erreur à cette ligne :

received = bufRead.readLine().trim();

Je sais bien que c'est normal que je récupère ces erreurs mais par contre mon interface plante aussi lors d'une de ces erreurs...

Je ne sais pas pourquoi car là j'ai bien différencier les 2 parties dans des Threads différents...

Auriez-vous une idée ?

Merci d'avance pour votre aide !!

Pour le réseau sinon, enfin, je ne sais pas si ça pourra t'aider mais j'ai un code que j'ai fait moi même. (Pour mon jeux.)

Ca devrait t'intéresser, il y a du TCP et de l'UDP, en même temps je mets ce code pour que tout ceux qui ont des problèmes avec le réseau aie un exemple concret :
Ma classe qui représente le serveur, à chaque connexion, c'est à dire à chaque fois que on sors de la méthode accept, je lance un nouveau Thread pour gérer la connexion avec le serveur.

package wotck.server;
import java.awt.*;
import java.net.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.io.*;

import javax.swing.*;
import java.awt.event.*;

public class WotckServer extends JFrame implements Runnable, ActionListener  {
        //Numéro de port utilisés pour les donées TCP et UDP.
	public static final int portTCP = 12000;
	public static final int portUDP = 13000;
	
	public static final String name = "War of the common strategy server.";		//Nom du serveur
        //Nom des requêtes envoyées.
	public static final String REQUETE_END = "DISCONNECT";
	public static final String REQUETE_AJOUTUDP = "NEWPLAYERCONNECTED";
	public static final String REQUETE_MAJUDP = "DEPLACEMENT_PERSO";
	public static final String REQUETE_READUDP = "POSITION_PERSOS";
	public static final String REQUETE_NBCONNECTED = "NB_CONNEXION";
	public static final String REQUETE_ADDMESSAGE =  "ADD_MESSAGE";
	//Vrai tant que le serveur est en marche.
	private static boolean isRunning;
	private static ServerSocket server = null; //Socket => serveur.	
	private static String message; //Simplement le message à renvoyé pour le chat.
	private static JButton arreter;	
	private static ArrayList<ThreadConnection> clients; //Liste des clients connectés.
	private static ArrayList<String> positionsPerso; //Liste de la positions des persos sur la map.
	private static DatagramSocket datagramSocket; //Socket pour l'UDP. (En mode non connecté!)
	
	
	public WotckServer () {
                //Constructeur, rien de bien particulier.
		super ("Serveur");                			
		clients = new ArrayList<ThreadConnection> ();		
		positionsPerso = new ArrayList<String> ();
		isRunning = false;
		
		setLocationRelativeTo (null);
		setResizable (false);
		setDefaultCloseOperation (EXIT_ON_CLOSE);
		addWindowListener (new ServerWindowListener ());
		arreter = new JButton ("Arrêter le serveur.");
		arreter.addActionListener(this);
		add (arreter);
		pack ();
		setVisible (true);
	}	
	//Méthode main, lance le serveur.
	public static void main (String[] args) {
		server = launchServer ();
		if (server == null)
			System.out.println("Erreur lors du lancement du serveur!");		
		
	}
        //Ajoute un message à renvoyer à tout le monde.
	public static void addMessage (String phrase) {
		message = phrase;		
	}
        //Envoie un message à tout le monde.
	public static void sendMessagesToAll () {
		String data = new String ();
		if (message != null) {
			data += REQUETE_ADDMESSAGE+"\n";
			data += message;		
			for (ThreadConnection c : clients) {			
				c.sendTCPData(data);
			}
		}
	}
        
	public static String getMessages () {
		return message;
	}
        //C'est ici qu'on lance le serveur!
	public static ServerSocket launchServer () {
		if (server == null) {
			try {			
                                		
				server = new ServerSocket (portTCP);	
				datagramSocket = new DatagramSocket (portUDP);
				
				System.out.println("Serveur lancé!");
                                //Création d'un thread pour lancer le serveur.
				new Thread (new WotckServer ()).start();
				
				return server;
			} catch (IOException e) {
				e.printStackTrace();
				return null;
			} 
		}
		return null;
	}
	public static ArrayList<String> getPositionsPlayer () {
		return positionsPerso;
	}
	public static ArrayList<ThreadConnection> getClientsConnected () {
		return clients;
	}
	
	public void run () {
		try {			
			
			isRunning = true;
			//Tant que le serveur est en marche, on attends indéfiniement une connexion.
			while (isRunning)	{	
				Socket socket = server.accept();
                                //A chaque connexion, on crée un nouveau thread pour gérer cette connexion.					
				ThreadConnection tcpCo = new ThreadConnection(socket, datagramSocket);		
                                //On ajoute le client à la liste des clients connectés.			
				clients.add(tcpCo);	
                                //Et on lance le thread qui devra gérer la connexion.			
				new Thread (tcpCo).start();	
				
			}
			
		} catch (IOException e) {
			e.printStackTrace();			
		} finally {
			try {
				server.close ();
				datagramSocket.close ();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			server = null;
		}
		System.exit(0);
	}
        //Ajoute la position d'un personnage.(A la connection = positions initiale.)
	public static void addPositionPerson (int position, String datas) {		
		
		positionsPerso.add(position, datas);
		
	}
        //Enlève la position d'un client à la déconnexion, on en a plus besoin.
	public static void removePositionPerson (int position) {		
		positionsPerso.set(position,  null);		
	}	
	@Override
        //J'arrête le serveur lors du clic sur un bouton.
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub			
		
		isRunning = false;
		try {
                        //Juste pour sortir de la méthode accept.
			new ThreadConnection (new Socket (server.getInetAddress(), portTCP), datagramSocket);
			
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		dispose ();		
	}	
        //Appelé à la déconexion d'un client, je l'enlève à la liste des clients connectés.
	public static void removeConnection (ThreadConnection co) {
		clients.remove(co);		
	}
        //Mets à jour la positions des personnages, cette méthode est appelée à chaque fois qu'un personnage bouge.
	public static void updateUDPPersonnagePosition (int id, String newDatas) {
		int pos = 0;
		String chaine = new String ();
		
		while (newDatas.charAt(pos) != '\0') {
			chaine += newDatas.charAt(pos);
			pos++;
		}		
		positionsPerso.set(id, chaine);
		
	}
        //En cas de fermeture de la fenêtre du serveur.
	private class ServerWindowListener extends WindowAdapter {		
		
		@Override
		public void windowClosing(WindowEvent e) {
			// TODO Auto-generated method stub	
			
			isRunning = false;	
			try {
				new ThreadConnection (new Socket (InetAddress.getByName("127.0.0.1"), portTCP), datagramSocket);
				
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}	
	}	
}

Ensuite j'ai fait la classe ThreadConnexion qui permet de gérer l'échange entre le serveur et un client, le client envoie une requête au serveur, et le serveur l'analyse et renvoie il réponse au client.

package wotck.server;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.net.*;

import java.io.*;

import javax.swing.*;



public class ThreadConnection extends JFrame implements Runnable {	
	//La socket venant du client.
	private  Socket socket;      
	private DatagramSocket datagramSocket;	
        //Attention ici c'est la socket côté serveur, UDP = mode non connecté!
	private static byte[] donneesRequete, donneesReponse = new byte[1000];
	private BufferedReader fluxEntree; //Flux.
	private BufferedWriter fluxSortie;
	private boolean isRunning;//Tant que le client est connecté.

	private DatagramPacket paquetRequete, paquetReponse;	
	private static int nbPlayerConnected = 0;

        //Création de la connexion.		
	public ThreadConnection (Socket socket, DatagramSocket datagramSocket) {
		this.socket = socket;
		this.datagramSocket = datagramSocket;		
		
	}	
        //Au lancement de la connexion.
	@Override
	public  void run() {
		// TODO Auto-generated method stub
		try {
			isRunning = true;
			fluxEntree = new BufferedReader (new InputStreamReader (socket.getInputStream()));
			fluxSortie = new BufferedWriter (new OutputStreamWriter (socket.getOutputStream()));
			
			String dataRead;			
			nbPlayerConnected ++;	
                        //Tant que le client est connecté et que l'on peut lire dans le flux d'entrée.				
			while (isRunning && (dataRead = fluxEntree.readLine()) != null) {					
				//On agit en fonction de la requête envoyée par le client.				
				if (dataRead.startsWith(WotckServer.REQUETE_AJOUTUDP)) {
					readUDPData ();
					String dataReaded = dataRead.substring(WotckServer.REQUETE_AJOUTUDP.length());				
					String[] parties = dataReaded.split(":");
					WotckServer.addPositionPerson(Integer.valueOf(parties[0]).intValue(), dataReaded);
				} else if (dataRead.startsWith(WotckServer.REQUETE_MAJUDP)) {					
					readUDPData ();
					String dataReaded = new String (donneesRequete);					
					String[] parties = dataReaded.split(":");					
					WotckServer.updateUDPPersonnagePosition(Integer.valueOf(parties[0]).intValue(), dataReaded);
				} else if (dataRead.startsWith(WotckServer.REQUETE_READUDP)) {	
					
					ArrayList<String> positionsPlayer = WotckServer.getPositionsPlayer();
					String chaine = new String ();
					for (int i = 0; i < positionsPlayer.size(); i++) {	
						if (positionsPlayer.get(i) != null)
						   chaine += positionsPlayer.get(i) + "\n";							
					}	
					
					donneesReponse = chaine.getBytes();
					sendUDPData (donneesReponse);
					fluxSortie.write(WotckServer.REQUETE_READUDP);
					fluxSortie.write("\n");
					fluxSortie.flush();
				} else if (dataRead.startsWith(WotckServer.REQUETE_NBCONNECTED)) {
					
					fluxSortie.write(WotckServer.REQUETE_NBCONNECTED);
					fluxSortie.write(String.valueOf(nbPlayerConnected));	
					fluxSortie.write("\n");
					fluxSortie.flush ();	
                                //A le déconnexion, le client envoie une requête de fin de connexion.				
				} else if (dataRead.startsWith(WotckServer.REQUETE_END)) {
					String s = dataRead.substring(WotckServer.REQUETE_END.length());
					System.out.println("Disonnect of one client");
					if (!s.equals("")) {
						String[] parties = s.split(":");						
						WotckServer.removePositionPerson(Integer.valueOf(parties[0]).intValue ());						
					}	
						
					isRunning = false;
				} else if (dataRead.startsWith(WotckServer.REQUETE_ADDMESSAGE)) {
					String dataReaded = dataRead.substring(WotckServer.REQUETE_ADDMESSAGE.length());					
					WotckServer.addMessage(dataReaded);		
					WotckServer.sendMessagesToAll();
				}
			} 
			
			nbPlayerConnected--;			
			WotckServer.removeConnection(this);					
			fluxEntree.close ();
			fluxSortie.close();
			socket.close();				
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}	
	//Envoie des données TCP à des clients
	public void sendTCPData (String data) {
		try {
			
			fluxSortie.write(data);
			fluxSortie.write("\n");
			fluxSortie.flush();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//Envoie des données UDP à des clients.
	public void sendUDPData (byte[] donnees) {
		try {		
			
			donneesReponse = donnees;
                        //Création d'un paquet pour l'envoi, on reprend l'@IP et le port du paquet reçus.			
			paquetReponse = new DatagramPacket (donneesReponse, donneesReponse.length, paquetRequete.getAddress(),  paquetRequete.getPort());
			datagramSocket.send(paquetReponse);	
							
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
	//Lis des données UDP en provenance d'un client.
	public void readUDPData () {		
		try {	
                        //Réallocation pour éviter de lire des "crasses" qui resteraient de l'échange précédant.
			 donneesRequete = new byte[1000];
			 paquetRequete = new DatagramPacket (donneesRequete, donneesRequete.length);
			 datagramSocket.receive(paquetRequete);	
			
		} catch (SocketException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
		
	}
	
}

Et enfin ma classe avec le client :

package wotck.client.main;
import java.io.*;
import java.net.*;
import java.util.*;

import javax.swing.SwingUtilities;

import wotck.config.Configuration;
import wotck.exceptions.ServerNotLaunchedException;
import wotck.gui.ChatGUI;
import wotck.jeu.Player;
import wotck.jeu.Vec3t;


import wotck.sqlclient.MySQLclient;
public class WotckClient extends Thread {	
	private Socket client;
	private DatagramSocket datagramSocket;
	private ArrayList<String> datas = new ArrayList<String> ();

	private BufferedReader fluxEntree;
	private BufferedWriter fluxSortie;
        //Port utilisé.	
	private static final int portTCP = 12000;	
	private static final int portUDPServer = 13000;
	//Adresse IP du serveur.
	private static String adresseServeur;
	private static InetAddress address;
	//Requêtes.
	public static final String REQUETE_READUDP = "POSITION_PERSOS";
	public static final String REQUETE_NBCONNECTED = "NB_CONNEXION";
	public static final String REQUETE_END = "DISCONNECT";
	public static final String REQUETE_ADDMESSAGE = "ADD_MESSAGE";
	public static final String REQUETE_MESSAGES = "READ_MESSAGES";
	private byte[] donneesRequete, donneesReponse = new byte[1000];
	private DatagramPacket paquetRequete, paquetReponse;
	private boolean isRunning;
	private ArrayList<String> positionsJoueurs;
	private int nbPlayerConnected;
	private LinkedList<String> messages; //Liste des messages. (chat)
	
	
	
	private Player player;	
	
	public WotckClient () throws ServerNotLaunchedException {		
		try {
			//L'adresse IP du serveur est mise dans un fichier de configuration.
			adresseServeur  = Configuration.getAdressIPServ();			
			address  = InetAddress.getByName(adresseServeur);
                        //Etablissement de la connexion entre le client et le serveur.
			client = new Socket (address, portTCP);
			//Création d'un socket UDP avec un numéro de port au hasart pour l'envoi et la réception de paquets.
			datagramSocket = new DatagramSocket ();
			fluxEntree = new BufferedReader (new InputStreamReader (client.getInputStream())); //Flux.
			fluxSortie = new BufferedWriter (new OutputStreamWriter (client.getOutputStream()));
			
			positionsJoueurs = new ArrayList<String> ();			
			messages = new LinkedList<String> ();
                        //Et on lance le thread qui lira les données venant du serveur.
			new Thread (this).start();
			
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}	
	
	public void setPlayer (Player player) {
		this.player = player;		
	}	
	public void disconnect () {
		
		if (player != null)	{
			
			sendRequest(REQUETE_END + player.getId());
		} else
			sendRequest(REQUETE_END);
		isRunning = false;
		MySQLclient.disconnect();
	}
        //Envoie de données UDP au serveur.
	public void sendUDPData (byte[] donnees) {
		try {	
			
			donneesRequete = donnees;	
			//On envoie le paquet avec l'adresse du destinataire, et le port du serveur.
			paquetRequete = new DatagramPacket (donneesRequete, donneesRequete.length, address,  portUDPServer);
			datagramSocket.send(paquetRequete);		
			
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
        //Envoi d'une requête TCP au serveur.
	public void sendRequest (String request) {				
		try {		
			
			fluxSortie.write(request);
			fluxSortie.write("\n");
			fluxSortie.flush ();
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}	
	public void run () {
		try {	
			String dataRead;
			isRunning = true;
			//Tant que le client est conecté et que l'on peut lire une donnée venant du serveur.
			while (isRunning && (dataRead = fluxEntree.readLine()) != null)  {	
				//On lit et on agit en fonction de la reuqête envoyée par le serveur.
				if (dataRead.startsWith(REQUETE_NBCONNECTED)) {				
					
					String s = dataRead.substring(REQUETE_NBCONNECTED.length());					
					nbPlayerConnected = Integer.valueOf (s).intValue();
					
				} else if (dataRead.startsWith(REQUETE_ADDMESSAGE)) {
					String chaineLue;
					chaineLue = fluxEntree.readLine();
			
					messages.addLast(chaineLue);					
					if (messages.size() > 5)
						messages.removeFirst();
					ChatGUI.drawMessages(messages);					
				}
                                //Lis à nouveau la position des personnages.
				else if (dataRead.startsWith(REQUETE_READUDP)) {
					
					readUDPData ();
					String s = new String (donneesReponse);	
					
					positionsJoueurs.clear();
					int i = 0;
					while (s.charAt(i) != '\0') {
						String chaineLue = new String ();
						while (s.charAt(i) != '\n') {
							chaineLue += s.charAt(i);	
							i++;
						}	
						i++;						
						positionsJoueurs.add(chaineLue);						
					}
					
				} 
			}
			fluxSortie.flush();	
			fluxEntree.close ();
			fluxSortie.close ();
			
			datagramSocket.close ();
			client.close ();
			
		} catch (IOException e) {
			e.printStackTrace();
		}		
	}
	public ArrayList<String> getPositionsJoueurs () {
		
		return positionsJoueurs;
	}
	public LinkedList<String> getMesages () {
		return messages;
	}
	public void readUDPData () {		
		try {	
                        //Lecture d'une donnée en provenance du serveur, on réalloue pour éliminer les restes.
			donneesReponse = new byte[1000];
			paquetReponse = new DatagramPacket (donneesReponse, donneesReponse.length);
			datagramSocket.receive(paquetReponse);
									
		} catch (SocketException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}			
	}
	public Player getPlayer() {		
		
		return player;
	}
	public boolean equals (WotckClient other) {
		return (player.equals(other.player) ? true : false);
	}
	
	public BufferedWriter getBW () {
		return fluxSortie;
	}
	
	
}

Voilà, peut être trop compliqué pour les zéros, mais, ça donne un exemple de l'utilisation d'une API client, serveur, j'espère que mon code pourra aider.

trifly

29 mai 2009 à 11:44:03

Bonjour à tous,

Je dialogue via l'API javax.comm avec un port série.

Je lui envoi des caractères et j'affiche, si il y a lieu, la réponse que je reçois suite à cet envoi.

C'est justement ici que ça coince, je n'arrive pas à ne rien afficher lorsque aucune réponse ne m'est envoyée...

J'ai suivi le tuto sur l'API javax.comm de developpez.com.

Voilà mon code pour l'envoi d'un caractère et la réception de la réponse :

public String communique_char(char envoie) {
	String received = "";
	try {
		// envoie du caractère
		outStream.write(envoie);
		outStream.write('\n');
		received = bufRead.readLine().trim();
	} catch (IOException e) {
	}
	return received;
}

Je souhaiterais que lorsque je ne reçois aucune réponse, donc lorsque ma chaîne received est null, je puisse lui attribuer une chaîne comme "Rien à afficher" pour ensuite la retourner.

Mais je ne vois pas comment faire...

J'ai essayé cela :

public String communique_char(char envoie) {
	String received = "";
	try {
		// envoie du caractère
		outStream.write(envoie);
		outStream.write('\n');

		//essai :
		try {
		received = bufRead.readLine().trim();
		} catch (IOException e){
			e.printStackTrace();
		}
		if (received.equals("")) {
			received = "Nothing to show";
		}

	} catch (IOException e) {
	}
	return received;
}

Mais cela ne marche pas, mon programme bug en attendant une réponse, cela doit venir de mon bufRead.readLine().trim() qui est vide mais je ne sais pas comment le traiter...

Quelqu'un aurait une idée ?

Je vous remercie d'avance pour vos réponses !

elmh

29 mai 2009 à 17:29:08

De ce que je sais la méthode readline() attend indéfiniment une réponse tant que le flux reste ouvert.
Donc faudrait peut-être voir dans quels cas de figure tu n'as rien à recevoir et agir en fonction de cela.

Simple idée je suis pas un expert en la matière

3 juin 2009 à 9:19:05

Bonjour elmh, désolé de ne répondre que maintenant,

Je me suis renseigné et, en effet, la méthode readLine() ne retourne quelquechose seulement si elle obtient une réponse ou qu'un timeout est survenu.

N'existe-t-il pas simplement une méthode qui donnerait un temps donné à une méthode ou une action pour s'exécuter puis au bout de ce laps de temps, stopperait cette action ?

Merci de ton aide !

Lolilolight

3 juin 2009 à 11:20:40

Salut, tu applique un while :

while ((String donnees = bufferEntree.readLine ()) != null) {
//Tant que il y a quelque chose à lire dans le fux, on le lis et on le met dans donnes.

}

Moi en tout cas, c'est comme ça que je fait et ça va, mon programme ne bloque pas.

3 juin 2009 à 11:35:59

Salut Lolilolight, j'ai essayé ta méthode mais sans succès :

public String communique_char(char envoie) {
	String received = "";
	try {
		// envoie du caractère
		outStream.write(envoie);
		outStream.write('\n');
		while ((received = bufRead.readLine ()) != null) {
			received.trim();
		}
	} catch (IOException e) {
		e.printStackTrace();
	}
	return received;
}

Je ne comprends pas ce que je dois mettre dans mon while ?
Même sans rien dedans, mon interface plante.

Merci !

Veldryn

3 juin 2009 à 11:46:26

Les flux sont un peu particuliers, ils ont en gros 3 états :

- Un caractère est disponible : read retourne tout de suite
- Aucun caractère n'est disponible : read attend...
- Le flux est fermé : read ne retourne rien (null ?) et termine

Il ne faut donc pas utiliser read pour ce que tu veux. En revanche, tu peux observer l'interface InputStream de plus près et remarquer par exemple cette méthode :

Citation : Javadoc - InputStream

available()
Returns an estimate of the number of bytes that can be read (or skipped over) from this input stream without blocking by the next invocation of a method for this input stream.

(En fait c'est pas une interface, c'est une classe abstraite

)

InputStream - available()

4 juin 2009 à 13:36:52

Ha oui juste ça saurait pas marcher mon truc, vu que mon programme est dans un Thread qui tourne indéfiniment en attendant une réponse, il ne sors de ma boucle while que à la déconnexion du client.

En effet c'est pas le même, soit tu utilise avalaible ou alors tu fait une variable booléenne que tu mets à false une fois qu'il a lu, mais je ne vois pas trop l'intérêt de sortir pendant la connexion.

9 juin 2009 à 10:01:23

19 juin 2009 à 9:08:25

Personne n'a une petite idée ?

19 juin 2009 à 9:59:39

API javax.comm

Problème réception port série

Supprimer

Modérer

Signaler le message aux modérateurs