récupérer trame NMEA via port série

**dude78** · 05/02/2009, 18h30

Bonjour à tous,

Je suis débutant en java, et je voudrais savoir comment adapter le programme suivant pour récupérer des trames NMEA d'un récepteur GPS via le port série du PC.
Dans la méthode de communication (milieu du programme) qu'est ce qui faudrait que je change pour récupérer les trames du récepteur GPS?

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
import javax.comm.*;
	import java.io.*;
	
	
	
	
	public class Flux {

		private BufferedReader bufRead; //flux de lecture du port
		private OutputStream outStream; //flux d'écriture du port
		private CommPortIdentifier portId; //identifiant du port
		private SerialPort sPort; //le port série
		/**
		 * Constructeur
		 */
		public Flux(String port) {
			//initialisation du driver
		
			//récupération de l'identifiant du port
			try {
				portId = CommPortIdentifier.getPortIdentifier("COM5");
			} catch (NoSuchPortException e) {
			}
			//ouverture du port
			try {
				sPort = (SerialPort) portId.open("Flux", 30000);
			} catch (PortInUseException e) {
			}
			//règle les paramètres de la connexion
			try {
				sPort.setSerialPortParams(
					9600,
					SerialPort.DATABITS_8,
					SerialPort.STOPBITS_1,
					SerialPort.PARITY_NONE);
			} catch (UnsupportedCommOperationException e) {
			}
			//récupération du flux de lecture et écriture du port
			try {
				outStream = sPort.getOutputStream();
				bufRead =
					new BufferedReader(
						new InputStreamReader(sPort.getInputStream()));
			} catch (IOException e) {
			}
		}
		/** 
		 * Méthode de communication.
		 */
		public String communique(char envoie) {
			String poids = null;
			try {
				//demande de poids
				outStream.write((int) envoie);
				//lecture du poids 
				poids = bufRead.readLine().trim();
			} catch (IOException e) {
			}
			return poids;
		}
		/**
		 * Méthode de fermeture des flux et port.
		 */
		public void close(){
			try {
				bufRead.close();
				outStream.close();
			} catch (IOException e) {
			}
			sPort.close();
		}
		/**
		 * Méthode principale de l'exemple.
		 */
		public static void main(String[] args) {
			
			
			
			//Récupération du port en argument
			String port = args[0];
			//Construction de l'interface à la balance
			Flux utilFlux = new Flux(port);
			//"interface utilisateur"
			System.out.println("taper q pour quitter, ou ENTER pour le poids");
			//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")) {
					System.out.println(utilFlux.communique('$'));
					lu = clavier.readLine();
				}
			} catch (IOException e) {
			}
			utilFlux.close();
		}
	}

Merci d'avance

**CheryBen** · 06/02/2009, 09h55

Bonjour, ce serait plus facile si tu expliquais ce qui se passe quand tu testes ce code.

J'ai déjà fait exactement ce que tu veux (lire des trames NMEA d'un GPS reçues sur le port COM), mais c'était il y a 2 ans et je n'ai plus accès le code.

La seule chose qui te manque, je pense, est un moyen de lire en boucle les trames du GPS. (dans un autre thread)

**dude78** · 07/02/2009, 18h19

Bonjour,

Dans mon projet créé dans Eclipse, il y a deux programmes : l'un gérant le flux sur le port com, l'autre gérant la conversion des données GPS.
Lorsque je lance le projet, ça me fait: Fatal exeption occured. Program will exit.

Après recherche j'ai vu qu'il y a 2 modes (flux et évennementiel).

Dans le mode que j'ai utilisé précédemment (mode flux), lorsqu'il n'y a pas de périphérique sur le port comme ça bloque le programme.
J'ai donc essayer le mode événementiel : l'écoute du port série se fait dans un thread. Mais Eclipse me fait la même erreur. voici le code :

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
import javax.comm.*;
 
import java.io.*;
import java.util.*;
 
public class Flux extends Thread implements SerialPortEventListener {
 
	private CommPortIdentifier portId;
	private SerialPort serialPort;
	private BufferedReader fluxLecture;
	private boolean running;
 
	/**
         * Constructeur qui récupère l'identifiant du port et lance l'ouverture.
         */
	public Flux(String port) {
		//initialisation du driver
 
 
		//récupération de l'identifiant du port
		try {
			portId = CommPortIdentifier.getPortIdentifier(port);
		} catch (NoSuchPortException e) {
		}
 
		//ouverture du port
		try {
			serialPort = (SerialPort) portId.open("ModeEvenement", 2000);
		} catch (PortInUseException e) {
		}
		//récupération du flux
		try {
			fluxLecture =
				new BufferedReader(
					new InputStreamReader(serialPort.getInputStream()));
		} catch (IOException e) {
		}
		//ajout du listener
		try {
			serialPort.addEventListener(this);
		} catch (TooManyListenersException e) {
		}
		//paramétrage du port
		serialPort.notifyOnDataAvailable(true);
		try {
			serialPort.setSerialPortParams(
				9600,
				SerialPort.DATABITS_7,
				SerialPort.STOPBITS_1,
				SerialPort.PARITY_EVEN);
		} 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 :
			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;
		}
	}
	/**
         * 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 = args[0];
		//lancement de l'appli
	 Flux modeEve=new Flux(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();
	}
}

Quelqu'un peut-il m'aider??
Merci d'avance

**CheryBen** · 08/02/2009, 09h34

Dans la mesure où aucune des exceptions n'est tracée, c'est difficile de connaitre le problème sans message d'erreur.

Tu devrais au moins mettre e.printStackTrace() dans tous les catch pour voir les messages d'erreur.

**dude78** · 08/02/2009, 16h26

Merci pour ta réponse. J'ai mis e.printStackTrace() dans certains des catch, et voila ce que j'obtient :

java.lang.ArrayIndexOutOfBoundsException: 0
at Flux.main(Flux.java:116)
Exception in thread "main"

Quand je clique sur Flux.java :116, il me surligne la ligne suivante :

String port = args[0];

D'où vient le problème??
Merci d'avance

**CheryBen** · 09/02/2009, 09h06

ArrayIndexOutOfBoundsException indique qu'on tente d'accéder à un index d'un tableau qui n'existe pas. Ce qui veut dire dans ton cas que args[0] n'existe pas, tu as lancé l'application sans arguments.

récupérer trame NMEA via port série

avec Java

Vue hybride

Discussions similaires

Partager

Partager