Receive eines Hex-Bytes über COM-Port

[Julian R.]

Hallo zusammen

Momentan bin ich dabei unter Verwendung von RXTX (RXTX: The Prescription for Transmission) über COM-Ports Hex-Messages zu senden und zu empfangen.

Hierbei wandle ich das Empfangene in Strings um, mappe diese, und sende entsprechend etwas auf einem beliebigem Port wieder raus.


Hierbei habe ich un mir wirklich total unbegreifliches Problem...

Und zwar liest mir das Programm immer anstatt das gesendete und auch rein physikalisch empfangene Byte "80" die zwei Bytes "20AC" ein.

Ich habe diesen Fehler auf alle Hex-Bytes eingrenzen können von "80" bis "9F". Alles dazischen wird falsch - d.h. als zwei falsche Bytes - aus dem Puffer ausgelesen, alles außerhalb richtig.

Rein Code-Technisch habe ich den Fehler auf den den

BufferedReader(new InputStreamReader(in))

zurückführen können. Lese ich diesen aus, so bekomme ich hier bereits die falschen Werte.
Für mich würde das eigentlich bedeuten, dass ich nichts von meiner Logik her falsch gemacht habe, sondern wenn dann nur bei der Verwendung des BufferedReader.

Ich konnte auch nach längerem hin- und her-shiften der einzelnen Bits und Anwendung diversester Rechenmethoden mit Bits und Bytes keine Verbindung zwischen dem eigentlich zu empfangendem und dem falschen, real empfangenem Byte(s) feststellen können.


Ich hoffe ihr könnt mir bei meinem Problem weiterhelfen!


Hier noch der relevante Source-Code:

Reader buf;
	ITransferable comManager = ComManager.getInstance();

	public SerialReader(InputStream in) {
		buf = new BufferedReader(new InputStreamReader(in));
	}

	public void run() {
		// nothing
	}

	@Override
	public void serialEvent(SerialPortEvent event) {
		String eventSource;
		switch (event.getEventType()) {
			case SerialPortEvent.DATA_AVAILABLE:
				try {
					// Kurz warten, damit alle Daten in den Puffer wandern, bevor er ausgelesen
					// werden soll.
					Thread.sleep(SleepTime.getTime());
				} catch (InterruptedException e) {
					System.out.println(e);
				}
				eventSource = event.getSource().toString();
				handleStreamBuffered(cutEventSource(eventSource));
				break;
			default:
				break;
		}
	}

	private String cutEventSource(String eventSource) {
		int indexOfCharacterC = eventSource.indexOf("C");
		return eventSource.substring(indexOfCharacterC, eventSource.length());
	}

	private void handleStreamBuffered(String eventSource) {
		int temp;
		try {
			StringBuilder builder = new StringBuilder();
			while (buf.ready()) {
				temp = buf.read();
//				System.out.println("Empfangener Wert als int: " + temp);
				String character = Integer.toHexString(temp);
				character = character.toUpperCase();
				if (character.length() == 1) {
					// Wir wollen die Daten immer zweistellig sehen.
					character = "0" + character;
				}
				builder.append(character);
				builder.append(" ");
			}
//			System.out.println("SerialReader.builder: " + builder.toString());
			RecievedData.getInstance().addText(builder.toString(), eventSource);
//			replyNeeded(builder.toString());
			
			builder = new StringBuilder();
		} catch (IOException e) {
			System.out.println(e);
		}
	}
[/Java]


Danke! :-)


Mit freundlichen Grüßen,

Julian R.

 

[Gastredner]

Ich bin nicht ganz sicher, aber ich denke, dein Problem könnte mit der Verwendung von Readern zusammenhängen. Reader versuchen, empfangene Bytes in lesbare Zeichen umzuwandeln. Probiere es stattdessen mal mit reinen Streams, z. B. einem BufferedInputStream.
BufferedInputStream (Java Platform SE 6)

 

[Julian R.]

Hm joa danke

Werd ich morgen gleich mal ausprobieren, und dann über das Ergebnis berichten! ;-)

 

[Julian R.]

Jawoll, daran lags!

Ich finds zwar immernoch nicht nachvollziehbar warum gerade diese bytes nicht richtig gelesen werden konnten, aber hauptsache es funktioniert erst mal =)!!!!

 

[KrokoDiehl]

Liegt vermutlich stark an der Kodierung, die die Reader verwenden wollen. Aber wenn sie z.B. ISO-8859-1 versucht haben, dann liegen da im Bereich 80-9F keine definierten Zeichen vor (vgl. ISO 8859-1 ? Wikipedia).