RS232 (COM-Port)

Alle JControl-basierte Geräte können standardmäßig über eine serielle Schnittstelle mit der "Außenwelt" kommunizieren. Die Module JControl/Sticker und JControl/PLUI lassen sich zudem direkt an die serielle Schnittstelle eines PCs anschließen. Die Module JControl/SmartDisplay und JControl/Stamp benötigen hierzu noch einen weiteren integrierten Baustein (RS232-Wandler, z.B. MAX232), wie er auch auf den jeweiligen "Evaluation Boards" zu finden ist. Neben der Möglichkeit, die Anwendungssoftware herauf- und herunterzuladen, kann die serielle Schnittstelle auch beliebig mit Java programmiert werden. Dieses Tutorial stellt die Implementierung eines einfachen seriellen Terminals mit Ausgabe auf das LC-Display vor.

Voraussetzungen: Für dieses Tutorial wird ein JControl-basiertes Gerät mit LC-Display benötigt (z.B. JControl/SmartDisplay).

Download: http://www.jcontrol.org/examples/RS232Example.zip Dieses Tutorial mit allen Quelltexten und Ressourcen als JControl/IDE-Projekt downloaden (ZIP-Archiv).

Die Klasse RS232

Den Zugriff auf die serielle Schnittstelle der JControl-Module ermöglicht die Klasse jcontrol.comm.RS232. Wichtig sind im Wesentlichen die folgenden Methoden:

Methode	Beschreibung
`RS232()`	Konstruktor für ein `RS232`-Objekt, das mit der Baudrate 19200 Bit/Sekunde (bps) initialisiert wird.
`RS232(int rate)`	Konstruktor für ein `RS232`-Objekt. Mit dem Parameter `rate` wird die gewünschte Baudrate übergeben.
`int available()`	Zeigt an, ob Zeichen über RS232 empfangen wurden.
`char read()`	Ein Zeichen aus dem RS232-Empfangspuffer auslesen (blockiert, bis ein Zeichen verfügbar ist).
`String readLine()`	Einen String einlesen (blockend, kehrt bei empfangenem Zeilenvorschub zurück).
`int write(char)`	Schreibt ein Zeichen auf die serielle Schnittstelle.
`void println(String)`	Sendet einen kompletten `String` über RS232.

Tabelle 1: Methoden der Klasse jcontrol.comm.RS232

Weitere Methoden ermöglichen gepuffertes Lesen und Schreiben sowie das Auslesen und Setzen diverser Schnittstellen-Parameter. Eine ausführliche Beschreibung der RS232-Methoden kann der API Dokumentation http://www.jcontrol.org/current/docs/api/jcontrol/comm/RS232.html entnommen werden.

Die Klasse DisplayConsole

Es soll nun ein serielles Terminal für JControl implementiert werden. Dieses soll fortlaufend Zeichen über RS232 empfangen und auf dem LC-Display ausgeben. Dazu bedienen wir uns der Klasse jcontrol.comm.DisplayConsole, die eine zeilenweise Ausgabe von Strings auf dem Display mit automatischem vertikalen Scrolling implementiert. DisplayConsole stellt mehrere Methoden zur Verfügung, wir werden ausschließlich println(String) verwenden. Weitere Informationen sind auf der entsprechenden Seite http://www.jcontrol.org/current/docs/api/jcontrol/comm/DisplayConsole.html der API-Dokumentation zu finden.

Methode	Beschreibung
`DisplayConsole()`	Erzeugt eine neue Instanz der Klasse `DisplayConsole`.
`void println(String)`	Schreibt den übergebenen `String` auf das LC-Display.

Tabelle 2: Für dieses Tutorial wichtige Methoden der Klasse jcontrol.comm.DisplayConsole

Implementierung

Schritt 1: Um das RS232-Terminal zu realisieren, muss zunächst eine Instanz von RS232 erzeugt werden. Dabei läßt sich die gewünschte Baudrate als Parameter übergeben. Wenn die RS232-Schnittstelle nicht geöffnet werden kann (beispielsweise weil sie schon von einem anderen Thread belegt ist), wird eine IOException ausgelöst. Diese kann in einem try-catch-Block abgefangen werden:

	try{
	rs232 = new RS232(BAUDRATE);
	} catch(IOException e) {
	new Display().drawString("IOError!", 0, 0);
	}

Schritt 2: Anschließend muss nur noch die Klasse DisplayConsole instantiiert und eine Endlosschleife gestartet werden, die abwechselnd zunächst eine Zeile von der seriellen Schnittstelle einliest und dann auf dem LCD ausgibt. Zeichenketten, die länger als der darstellbare Bereich sind, werden automatisch gekürzt. Der folgende Quelltext zeigt die vollständige Implementierung des RS232Example. Die Endlosschleife ist in der Methode terminal() lokalisiert.

Bild 1: Screenshot des RS232Example

1	import java.io.IOException;
2
3	import jcontrol.comm.DisplayConsole;
4	import jcontrol.comm.RS232;
5	import jcontrol.io.Display;
6
7	/**
8	* <p>RS232Example shows how to write a RS232 terminal
9	* for JControl using the API classes <code>RS232</code>
10	* and <code>DisplayConsole</code>.</p>
11	*
12	* <p>(C) DOMOLOGIC Home Automation GmbH 2003-2005</p>
13	*/
14	public class RS232Example {
15	/** RS232 access */
16	RS232 rs232;
17	/** DisplayConsole */
18	DisplayConsole console;
19
20	/** baud rate */
21	final static int BAUDRATE = 19200;
22
23	/**
24	* Init and start the RS232 console.
25	*/
26	public RS232Example() {
27	// init RS232 access
28	try {
29	rs232 = new RS232(BAUDRATE);
30	} catch (IOException e) {
31	new Display().drawString("IOError!",0,0);
32	}
33
34	// init DisplayConsole
35	console = new DisplayConsole();
36
37	// say hello
38	console.println("JControl RS232 Terminal ready.");
39
40	// start RS232 terminal
41	terminal();
42	}
43
44	/**
45	* The RS232 terminal implementation
46	*/
47	void terminal() {
48	String s;
49
50	// continuously receive from RS232 and write to lcd
51	for (;;) {
52	try {
53	s = rs232.readLine();
54	console.println(s);
55	} catch (IOException e) {
56	// reset errorflag
57	rs232.errorCode();
58	}
59	}
60	}
61
62	/**
63	* Main method. Program execution starts here.
64	*/
65	public static void main(String[] args) {
66	new RS232Example();
67	}
68	}

Listing 1: RS232Example.java

Schritt 3: Laden Sie nun das RS232Example in die JControl/IDE und programmieren Sie damit Ihr JControl-Modul. Sie können nun das in die JControl/IDE (ab Version 3.0.1 und höher) integrierte RS232-Terminal verwenden um über die serielle Schnittstelle mit dem JControl-Modul zu kommunizieren. Alternativ öffnen Sie ein Terminalprogramm (unter Windows z.B. HyperTerminal, zu finden im Startmenü unter Programme->Zubehör->Kommunikation) und stellen die passenden Schnittstellenparameter ein (19200 Baud, 8 Datenbits, keine Parity, 1 Stoppbit, keine Flusskontrolle). Nun erscheinen alle Zeichen, die Sie in das Terminalprogramm eingeben, auf dem LC-Display des JControl-Moduls. Dabei ist zu beachten, dass wir im Quelltext die Methode rs232.readLine() verwenden, die erst dann zurückkehrt, wenn ein Zeilenvorschub (Linefeed) erkannt wurde. In das Terminalprogramm eingegebene Zeichen werden daher erst nach Betätigung der Eingabetaste auf dem JControl-Modul angezeigt.