Discussion :

[dude78]

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]

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]

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]

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]

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]

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.

[dude78]

Comment ça sans argument. Est que tu peut être plus précis?

Merci

[dude78]

Ce que tu veux dire, c'est que la variable args n'est pas forcément instanciée.
Si je ne passe pas de paramètre a mon appel à l'exécutable java, args[0] n'existe pas.
Comment faire ?
Merci d'avance

[CheryBen]

Il suffit de regarder où est utilisé args[0] pour voir que cela doit correspondre au port name que tu souhaites ouvrir. Je pense que cela correspond à COM1, COM2, ...

[dude78]

Le port que j'utilise pour récupérer les données est le port COM5. Faut il que je rajoute des lignes de code dans mon programme?

[CheryBen]

Non, c'est au lancement de ton programme que tu dois donner COM5 en argument, par exemple : java package.Flux COM5

[dude78]

Comment donner COM5 en argument alors que le programme me dit fatal error quand quand je le lance?

[dude78]

Le programme gérant la récupération des trames sur le port COM marche à présent. Mais comment faire la liaison avec la partie conversion?

voici le code de la partie conversion

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
public final static double[] WGS84toLambert2e(double d_long, double m_long, double s_long, char orientation_long, double d_lat, double m_lat, double s_lat , char orientation_lat)
{
    double lambda_w, phi_w;
 
 
 
 
    /**************************************************************************************************************/
    /**        0) degres-minutes-secondes + orientation (d,m,s,o) -> radian                                           **/
    /**************************************************************************************************************/
 
    // Pour la longitude
    lambda_w = d_long + m_long/60 + s_long/3600;
    if(orientation_long == 'W') lambda_w = -1 * lambda_w; // Le système de coordonnées géographiques utilisé est postif vers le Nord et vers l'Est
    lambda_w =  lambda_w*Math.PI/180 ;
 
    // Pour la latitude
    phi_w = d_lat + m_lat /60 + s_lat /3600;
    if(orientation_lat == 'S') phi_w = -1 * phi_w;          // Le système de coordonnées géographiques utilisé est postif vers le Nord et vers l'Est     
    phi_w = phi_w*Math.PI/180 ;
 
    /**************************************************************************************************************/
    /**        1) coordonnées géographiques WGS84 (phi_w,lambda_w) -> coordonnées cartésiennes WGS84 (X_w,Y_w,Z_w)  **/
    /**************************************************************************************************************/
 
    // Nous avons utilisés 2 formules données par l'IGN dans un de leur document ainsi que deux constantes de 
    // l'ellipsoide de référence associé au système WGS84 (les deux demi-axes) :
 
    double a_w = 6378137.0;// demi grand axe
    double b_w = 6356752.314;// demi petit axe
 
    // d'où
    double e2_w = (a_w*a_w-b_w*b_w)/(a_w*a_w);
 
    // et on a la grande normale de l'ellipsoide WGS84
    double N = a_w/Math.sqrt(1 - e2_w * Math.pow(Math.sin(phi_w),2));
 
    // ainsi on obtient
    double X_w = N * Math.cos(phi_w) * Math.cos(lambda_w);
    double Y_w = N * Math.cos(phi_w) * Math.sin(lambda_w);
    double Z_w = N * (1-e2_w) * Math.sin(phi_w);
 
    /**************************************************************************************************************/
    /**        2) coordonnées cartésiennes WGS84 (X_w,Y_w,Z_w) -> coordonnées cartésiennes NTF (X_n,Y_n,Z_n)          **/
    /**************************************************************************************************************/
 
    // Là il n'y a qu'une translation à effectuer :
 
    // on a donc
    double dX = 168.0;
    double dY = 60.0;
    double dZ = -320.0;
 
 
    double X_n = X_w + dX;
    double Y_n = Y_w + dY;
    double Z_n = Z_w + dZ;
 
    /**************************************************************************************************************/
    /**        3) coordonnées cartésiennes NTF (X_n,Y_n,Z_n) -> coordonnées géographiques NTF (phi_n,lambda_n)      **/
    /**************************************************************************************************************/
 
    // J'ai utilisé 1 formule donnée par l'IGN toujours dans le même document ainsi que deux constantes de l'ellipsoide 
    // de référence du système NTF, Clarke 1880 :
 
    double a_n = 6378249.2;
    double b_n = 6356515.0;
 
    // d'où
    double e2_n = (a_n*a_n-b_n*b_n)/(a_n*a_n);
 
    // on définit une tolérance de convergence
    double epsilon = Math.pow(10,-10);
 
    // puis on amorce une boucle de calcul        
    double phi0 = Math.atan(Z_n/Math.sqrt(X_n*X_n+Y_n*Y_n)*(1-(a_n*e2_n)/(Math.sqrt(X_n*X_n+Y_n*Y_n+Z_n*Z_n))));
    double phi1 = Math.atan((Z_n/Math.sqrt(X_n*X_n+Y_n*Y_n))/(1-(a_n*e2_n*Math.cos(phi0))/(Math.sqrt((X_n*X_n+Y_n*Y_n)*(1-e2_n*Math.pow(Math.sin(phi0),2))))));
 
    while(!(Math.abs(phi1-phi0)<epsilon))
    {
 
        phi0 = phi1; phi1 = Math.atan((Z_n/Math.sqrt(X_n*X_n+Y_n*Y_n))/(1-(a_n*e2_n*Math.cos(phi0))/(Math.sqrt((X_n*X_n+Y_n*Y_n)*(1-e2_n*Math.pow(Math.sin(phi0),2)))))); 
 
    }
 
    double phi_n = phi1;
    double lambda_n = Math.atan(Y_n/X_n);
 
    /**********************************************************************************************************************/
    /**        4) coordonnées géographiques NTF (phi_n,lambda_n)  coordonnées projetées en Lambert II étendu (X_l2e, Y_l2e) **/
    /**********************************************************************************************************************/
 
    // Nous utilisons les formules de projection et les constantes fournies par l'IGN dans un autre document :
 
    // avant tout on définit quelques constantes
    double n = 0.7289686274;
    double c = 11745793.39;
    double Xs = 600000.0;
    double Ys = 8199695.768;
 
    double e_n = Math.sqrt(e2_n);
    double lambda0 = 0.04079234433198;   //correspond à la longitude en radian de Paris (2°20'14.025" E) par rapport à Greenwich
    // puis on calcule la latitude isométrique
    double L = Math.log(Math.tan(Math.PI/4 + phi_n/2) * Math.pow(((1-e_n*Math.sin(phi_n))/(1+e_n*Math.sin(phi_n))),(e_n/2)));
 
    // enfin on projette
 
    double X_l2e = Xs + c*Math.exp((-n*L))*Math.sin(n*(lambda_n-lambda0));
    double Y_l2e = Ys - c*Math.exp((-n*L))*Math.cos(n*(lambda_n-lambda0));
 
    double[]tabXY = new double[2];
 
    tabXY[0] = X_l2e;
    tabXY[1] = Y_l2e;
 
    return tabXY;
 
 
 
 
 
}
}

[CheryBen]

Dans la mesure où ta méthode est public et static, il suffit de l'appeler comme ça :

Code :

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

double[] doubleTab = NomDeClasse.WGS84toLambert2e(paramètres...);

[dude78]

Cette ligne je la met dans le main?

double[] doubleTab = ModeEvenement.WGS84toLambert2e(double d_long, double m_long, double s_long, char orientation_long, double d_lat, double m_lat, double s_lat , char orientation_lat);

Voici les erreurs :

Multiple markers at this line
- s_long cannot be resolved
- Syntax error on token "char", delete this
token
- Syntax error on token "double", delete
this token
- Syntax error on token "double", delete
this token
- d_long cannot be resolved
- Syntax error on token "double", delete
this token
- Syntax error on token "double", delete
this token
- Syntax error on token "double", delete
this token
- Syntax error on token "double", delete
this token
- m_lat cannot be resolved
- orientation_long cannot be resolved
- orientation_lat cannot be resolved
- Syntax error on token "char", delete this
token
- d_lat cannot be resolved
- m_long cannot be resolved

J'essaie d'enlever les double dans la parenthèse, ou de mettre au dessus de cette ligne : double d_long; idem pour les autres. Dans ce dernier cas il faut que j'initialise les variables.
Comment faire?
Merci d'avance

voici le code de récupération du flux :

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
import javax.comm.*;
import java.io.*;
import java.util.*;
 
 
 
public class ModeEvenement{
	static  CommPortIdentifier portId;
	static  BufferedInputStream in;
	static  SerialPort serialPort;
	static  String sentence;
	static  String com=null;
	static  protected byte[] buf;
	static  int nb=0;
	static private BufferedReader bufRead;
 
 
 
 
 
//le constructeur prend en parametre le port serie a utiliser
//public Communication( String com )
//{
//  this.com=com;
 
//}
 
 
 
public static void main( String[] argv )
{
 
System.out.println("liste de ports series disponibles");
Enumeration portList = CommPortIdentifier.getPortIdentifiers();
if (portList == null) {
  System.out.println("Aucun port de communication detecte ");
}
while (portList.hasMoreElements()) {
  portId = (CommPortIdentifier) portList.nextElement();
  System.out.println(portId.getName());
}
 
try{
portId=CommPortIdentifier.getPortIdentifier("COM5");
}catch(NoSuchPortException ex){System.out.println("port inconnu");}
try{
 
 
serialPort = (SerialPort) portId.open("Communication", 9000);
/*les parametres de port serie  selon le standard NMEA
 vitesse:4800;8 bits de donnees;aucun bit de parite;un bit de stop
 */
 
serialPort.setSerialPortParams(4800, SerialPort.DATABITS_8,
                               SerialPort.STOPBITS_1,
                               SerialPort.PARITY_NONE);
System.out.println("ouverture de port" + "COM5");
} catch  (Exception eee) {System.out.println("echeccccccccccc");
// e.printStackTrace();
}
 
for(int i=0;i<100;i++)
{
try {
 String poids = null;
 bufRead =
     new BufferedReader(
     new InputStreamReader(serialPort.getInputStream()));
 poids = bufRead.readLine().trim();
 System.out.println(poids);
 /* in = new BufferedInputStream(serialPort.getInputStream());
  while (nb != ( -1)) {
    nb = in.read();
  }
  sentence = new String(buf);
  System.out.println(sentence);*/
 poids = null;
 
}
catch (Exception e) {
 System.out.println("echec");
 // e.printStackTrace();
}
}
}

[CheryBen]

Je crois que tu devrais revoir les bases du java, notamment comment appeler une méthode.

Il faut forcément initialiser les paramètres que tu donnes à une méthode, sinon qu'en ferait-elle?

Et que mettre dedans, sûrement les éléments que tu as extrait de la trame.