Reprendre la main sur OSGi

[darkbird]

Bonjour,

Je débute plus ou moins avec OSGi, et j'aurais besoin d'aide.

Je souhaite que mon bundle lise un port série (via le port USB) et enregistre les infos, par exemple dans un fichier.

J'ai donc utilisé la librairie RXTXcomm, que j'ai transformée en bundle OSGi pour exporter le package gnu.io, et j'ai développé un autre bundle (test_serial), en m'aidant d'exemples sur le net, pour l'utilisation que j'ai décrite.

Mon problème est que le bundle fait exactement ce que je souhaite, mais je ne peux plus interagir avec le framework (ss, install, start, stop par ex...). J'utilise Equinox sous Eclipse.

Quelqu'un aurait il la solution ? ci après mon code :

activator :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void start(BundleContext bundlecontext) throws Exception {
	Activator.context = bundlecontext;
 
	System.out.println("Hello World!!");
	String rate="115200";
 
	test_serial l=new test_serial();
	l.rate=Integer.parseInt(rate);
 
	try {
		l.connect("/dev/ttyUSB0");
	} catch (Exception e) {
		e.printStackTrace();
	}
}

classe test_serial :

Code :

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
package test;
 
import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import org.apache.commons.codec.binary.Hex;
 
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
//import org.apache.commons.codec.binary.Hex;
 
public class test_serial {
 
	int rate=115200; 
 
	public test_serial() {
		super();
	}
 
	void connect(String portName) throws Exception {
		CommPortIdentifier portIdentifier = CommPortIdentifier
				.getPortIdentifier(portName);
		if (portIdentifier.isCurrentlyOwned()) {
			System.out.println("Error: Port is currently in use");
		} else {
			CommPort commPort = portIdentifier.open(this.getClass().getName(),
					2000);
 
			if (commPort instanceof SerialPort) {
				SerialPort serialPort = (SerialPort) commPort;
				//serialPort.setSerialPortParams(57600, SerialPort.DATABITS_8,SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
				//serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8,SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
				serialPort.setSerialPortParams(rate, SerialPort.DATABITS_8,SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
 
 
				InputStream in = serialPort.getInputStream();
				OutputStream out = serialPort.getOutputStream();
 
				(new Thread(new SerialReader(in))).start();
				(new Thread(new SerialWriter(out))).start();
 
			} else {
				System.out
						.println("Error: Only serial ports are handled by this example.");
			}
		}
	}
 
	/** */
	public static class SerialReader implements Runnable {
		InputStream in;
 
		public SerialReader(InputStream in) {
			this.in = in;
		}
 
		public void run() {
			PrintWriter out = null;
			byte[] buffer = new byte[1];
			int flag = 1;
			int len = -1;
			try {
				out = new PrintWriter(new BufferedWriter(new FileWriter(
						"/home/new.txt",true)));
 
				while ((len = this.in.read(buffer)) > -1) {
					String next=new String(Hex.encodeHex(buffer)); /*Hex.encodeHex(buffer)    new String(buffer,0,len);*/
					if(next.equals("7e")){
						next = "";
						if(flag == -1)
							next = next.concat("\n");
						flag = flag*(-1);
					}
					System.out.print(next);
					out.print(next);
					out.flush();
				}
			} catch (IOException e) {
				if (out != null)
					out.close();
				e.printStackTrace();
			}
		}
	}
 
	/** */
	public static class SerialWriter implements Runnable {
		OutputStream out;
 
		public SerialWriter(OutputStream out) {
			this.out = out;
		}
 
		public void run() {
			try {
				int c = 0;
				while ((c = System.in.read()) > -1) {
					this.out.write(c);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
 
	public static void main(String[] args) {
	}
}

Merci beaucoup

[sekaijin]

Bonjour,

je ne sais quel est ton besoin precis mais si c'est se mettre à l'écoute du port serie et réagir à chaque "message" reçus, ou en fonction d'événement envoyer des "messages" sur ton port serie
je te propose de changer complètemen d'optique.

l'idée passer par Camel
créer un composant camel n'est pas très compliqué
l'avatage camel prend en charge toute la gestions de thread et concentre le dev sur le flux de donnée

je te propose de lire
http://blog.xebia.fr/2010/09/30/cree...lapns-1-sur-3/
http://blog.xebia.fr/2010/10/06/cree...lapns-2-sur-3/
http://blog.xebia.fr/2010/10/13/cree...lapns-3-sur-3/

sur le principe de ce composant tu peux faire un connecteur rxtx
ensuite dans un bundle tu definie une route camel

Code :

from("rxtx:monport").bean(MaClasse.class);

tu crée une classe MaClasse qui contient une méthode pour traiter chaque "message" que ton composant rxtx envoie
de même tu peux envoyer ce que tu veux sur ton composant
en faisant

Code :

from("...").to("rxtx:monport");

le tout est déployable dans osgi

ça demande un peux de prise en main et pas mal de lecture par contre ensuite c'est très réutilisable tu peux créer des "routes" qui te permettent d'interfacer ton composant avec toutes sorte de protocole et bien sur invoquer sur événement tout process de ton choix

A+JYT

[Deaf]

Bonjour,

tu as toujours accès au framework, au travers du BundleContext que récupère ton Activator dans la méthode start.

A partir de lui, tu peut récupérer le bundle system (0) et l'arrêter par exemple.

[sekaijin]

de façon générale dans un bundle ma méthode start ne fait toujours que lancer un thread et rendre la main.

A+JYT