[B@6a435f in normalen Zahlen umwandeln, wie?

[prashanna]

Hallo zusammen

Ich arbeite gerade an einem Projekt, wo ich vom seriellen Ports Daten einlese. Wenn ich es ausgebe, bekomme ich folgende Ergebnisse:

byte[] readBuffer = new byte[BLOCKSIZE];
System.out.println(readBuffer);

...
[B@1758cd1
[B@6a435f
[B@6d1750
[B@15a94f
...

Ich möchte dies als Zahl oder Hexa ausgeben, wie muss ich vorgehen?
Wenn ich mich nicht irre ist das die Adresse von byte Array, oder, wie muss ich programmieren, das es verständlich wird
Ich danke schon voraus für gute Antworten.

Gruss
Prashanna

 

[nillehammer]

Wenn es nur darum geht, die (byte-)Elemente des Arrays anzuzeigen, dann am besten so:

System.out.println(Arrays.toString(readBuffer));

 

[prashanna]

Hi nillehammer

Danke für deine schnelle Antowrt. Leider funktioniert das bei mir nicht, ich bekomme nur 0.

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Habe ich da was flasch gemacht?

Gruss
prashanna

 

[TKausL]

Dann ist das Array nicht gefüllt...

byte[] readBuffer = new byte[BLOCKSIZE];

natürlich sind die Array-Elemente alle 0 zu beginn.

 

[Timothy Truckle]

Leider funktioniert das bei mir nicht, ich bekomme nur 0.

Was hast Du denn erwartet?

bye
TT

 

[nillehammer]

Habe ich da was flasch gemacht?

Das Verhalten hat TKausL ja schon erklärt. Zur Frage, was Du falsch gemacht hast, kann ich nur vermuten, weil der Rest des Codes ungekannt ist. Ich nehme mal an, dass Du das byte-Array als Puffer für einen Stream benutzt. Wenn das so ist, dann initialisiere ihn nur einmal am Anfang. Dann fülle ihn mittels read (evtl. mehrmals mittels einer Schleife) und mache jeweils nach dem read das System.out.println.

 

[prashanna]

Hallo zusammen
Danke für eure Kritik

Wenn ich über eine Schleife mache, bekomme ich das gleiche...

byte[] readBuffer = new byte[BLOCKSIZE];
        String stream = "";
        String[]temp2 = new String[BLOCKSIZE];
        String temp;
        for(i=0;i < readBuffer.length;i++){
            readBuffer[i] = (byte)readBuffer[i];
            temp = Integer.toBinaryString((int)readBuffer[i]);
            for(int j = 0;j < temp.length(); j++){
                stream += temp.charAt(j);
            }
            temp2[i] = stream;
        }
        System.out.println(temp2);

Da die Quelltext von der Schule stammt, weiss ich nicht ob ich es hier posten darf. Ich hoffe, dennoch auf gute Unterstützung.

 

[nillehammer]

Es wird dem readBuffer nirgends in dem Code ein sinnvoller Wert zugewiesen. Nach Initialisierung in Zeile 1 sind alle Elemente 0. "Belegt" werden -soweit ich das sehe- die Elemente nur in Zeile 6, sonst nirgends. In Zeile 6 steht das hier:
[JAVA=6]
readBuffer = (byte)readBuffer;
[/code]
Wenn Du lange genug schaust, merkst Du was?

 

[TKausL]

Was tust du da?

readBuffer[i] = (byte)readBuffer[i];
            temp = Integer.toBinaryString((int)readBuffer[i]);

Du schreibst die 0 die bereits im readBuffer steht nochmal (gecastet) in readBuffer. Es bleibt also 0 drin.
Dann schreibst du die 0 in temp und von dort aus dann in den stream. Anschließend den stream (immernoch 0) in temp2. Am ende sieht das Array temp2 genauso aus wie readBuffer (überall 0) nur, dass in temp2 die 0 als String gespeichert ist...

 

[prashanna]

Danke

Habe jetzt so geändert
oben habe ich readBuffer initialisert und leere Werte zugewiesen.

static public  final int            EMPTY_BYTE = 0;
static public  final int            BLOCKSIZE   = 14; 
static private byte[]             readBuffer = new byte[BLOCKSIZE];
....

 for (i=0; i<BLOCKSIZE; i++){
            readBuffer[i] = EMPTY_BYTE;
}
....

String stream = "";
        String[]temp2 = new String[BLOCKSIZE];
        String temp;
        for(i=0;i < readBuffer.length;i++){
            readBuffer[i] = (byte)readBuffer[i];
            temp = Integer.toBinaryString((int)readBuffer[i]);
            for(int j = 0;j < temp.length(); j++){
                stream += temp.charAt(j);
            }
            temp2[i] = stream;
        }
        System.out.println(temp2);

Geht leider auch net .....


EDIT:
Also leer ist der readBuffer nicht

wenn ich nur readBuffer ausgebe, bekomme ich etwas zurück.

System.out.println(readBuffer);

OK, got DATA Block of 14 Bytes
[B@10f0625
OK, got DATA Block of 14 Bytes
[B@10f0625
OK, got DATA Block of 14 Bytes
[B@10f0625
OK, got DATA Block of 14 Bytes
[B@10f0625
OK, got DATA Block of 14 Bytes
[B@10f0625
OK, got DATA Block of 14 Bytes
[B@10f0625
OK, got DATA Block of 14 Bytes
[B@10f0625
...

 

[TKausL]

readBuffer[i] = (byte)readBuffer[i];

ist immernoch so sinnlos wie vorher.

Woher kommt denn das "OK, got DATA Block of 14 Bytes"? Wo wird readBuffer denn gefüllt?
Wir brauchen mehr Code!

 

[prashanna]

Hallo Hier ganze Skript

import gnu.io.*;

import java.io.IOException;
import java.io.InputStream;
//import java.io.OutputStream;
import java.util.Enumeration;
import java.util.TooManyListenersException;

//import OeffnenUndSenden.serialPortEventListener;



public class EinfachEmpfangen implements Runnable {

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		Runnable runnable = new EinfachEmpfangen();
		new Thread(runnable).start();
		System.out.println("main finished");
	}
	
	/**
	 * 
	 */

	CommPortIdentifier serialPortId;
	Enumeration enumComm;
	SerialPort serialPort;
	//OutputStream outputStream;
	InputStream inputStream;
	Boolean serialPortGeoeffnet = false;

	int baudrate = 9600;
	int dataBits = SerialPort.DATABITS_8;
	int stopBits = SerialPort.STOPBITS_1;
	int parity = SerialPort.PARITY_NONE;
	String portName = "COM1";
	
	int secondsRuntime = 60;

	public EinfachEmpfangen()
	{
		System.out.println("Konstruktor: EinfachSenden");
	}
	
    @Override
    public void run()
    {
        Integer secondsRemaining = secondsRuntime;
        if (oeffneSerialPort(portName) != true)
        	return;
        
		while (secondsRemaining > 0) {
			System.out.println("Sekunden verbleiben: " + secondsRemaining.toString() );
			secondsRemaining--;
			try {
				Thread.sleep(1000);
			} catch(InterruptedException e) { }
		}
		schliesseSerialPort();
    	
    }
    
	boolean oeffneSerialPort(String portName)
	{
		Boolean foundPort = false;
		if (serialPortGeoeffnet != false) {
			System.out.println("Serialport bereits geöffnet");
			return false;
		}
		System.out.println("Öffne Serialport");
		enumComm = CommPortIdentifier.getPortIdentifiers();
		while(enumComm.hasMoreElements()) {
			serialPortId = (CommPortIdentifier) enumComm.nextElement();
			if (portName.contentEquals(serialPortId.getName())) {
				foundPort = true;
				break;
			}
		}
		if (foundPort != true) {
			System.out.println("Serialport nicht gefunden: " + portName);
			return false;
		}
		try {
			serialPort = (SerialPort) serialPortId.open("Öffnen und Senden", 500);
		} catch (PortInUseException e) {
			System.out.println("Port belegt");
		}
/*
		try {
			outputStream = serialPort.getOutputStream();
		} catch (IOException e) {
			System.out.println("Keinen Zugriff auf OutputStream");
		}
*/
		try {
			inputStream = serialPort.getInputStream();
		} catch (IOException e) {
			System.out.println("Keinen Zugriff auf InputStream");
		}
		try {
			serialPort.addEventListener(new serialPortEventListener());
		} catch (TooManyListenersException e) {
			System.out.println("TooManyListenersException für Serialport");
		}
		serialPort.notifyOnDataAvailable(true);
		try {
			serialPort.setSerialPortParams(baudrate, dataBits, stopBits, parity);
		} catch(UnsupportedCommOperationException e) {
			System.out.println("Konnte Schnittstellen-Paramter nicht setzen");
		}
		
		serialPortGeoeffnet = true;
		return true;
	}

	void schliesseSerialPort()
	{
		if ( serialPortGeoeffnet == true) {
			System.out.println("Schließe Serialport");
			serialPort.close();
			serialPortGeoeffnet = false;
		} else {
			System.out.println("Serialport bereits geschlossen");
		}
	}
	
	void serialPortDatenVerfuegbar() {
		try {
			byte[] data = new byte[150];
			int num;
			while(inputStream.available() > 0) {
				num = inputStream.read(data, 0, data.length);
                                System.out.println(data); [B]-->[/B] hier kommt [B@1893efe, [B@186c6b2 raus
			}
		} catch (IOException e) {
			System.out.println("Fehler beim Lesen empfangener Daten");
		}
	}

	class serialPortEventListener implements SerialPortEventListener {
        @Override
		public void serialEvent(SerialPortEvent event) {
			System.out.println("serialPortEventlistener");
			switch (event.getEventType()) {
			case SerialPortEvent.DATA_AVAILABLE:
				serialPortDatenVerfuegbar();
				break;
			case SerialPortEvent.BI:
			case SerialPortEvent.CD:
			case SerialPortEvent.CTS:
			case SerialPortEvent.DSR:
			case SerialPortEvent.FE:
			case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
			case SerialPortEvent.PE:
			case SerialPortEvent.RI:
			default:
			}
		}
	}	
}

Die Ausgabe kommt in der Zeile 137.

 

[Kevin94]

Schaust du dir deinen Code auch nochmal an, ob der in irgendeiner Weise sinnvoll ist?

void serialPortDatenVerfuegbar() {
        try {
            byte[] data = new byte[150];
            int num;
            while(inputStream.available() > 0) {
                num = inputStream.read(data, 0, data.length);
                                System.out.println(data);
            }
        } catch (IOException e) {
            System.out.println("Fehler beim Lesen empfangener Daten");
        }
    }

Was fällt dir bei dieser Methode auf? Was mir als erstes auffält, ist das dein bisheriger, geposteter Code nirgends in der Klasse aus deinem letzten Post auftaucht und das diese Zeile so nicht für die Ausgabe verantwortlich seien kann und das die lokale Variable in der die gelesenen Daten gespeichert werden einfach verworfen wird und nichts damit gemacht wird.
Wenn ich noch über die Eleganz des Codes reden müsste, würde ich mich fragen, warum man erstens für den Timeout einen neuen Thread aufmacht, das ginge genauso im main-Thread, und zweitens, warum du dafür nicht die Klasse [JAPI]Timer[/JAPI] verwendest.

PS: Die "komischen" Ausgaben wie [B@1893efe sind das Ergebnis der normalen toString-Methode von Object. Diese setzt sich aus KlassenName@HashCodeAlsHex zusammen. Wobei den primitiven Typen jeweils ein Buchstabe als Klassennamen zugeordnet ist und für Arrays eine [ voran gestellt wird.

 

[prashanna]

Und wie kann ich die HAshCodealsHex in bitweise oder in Hexa ausgeben?

die oben gepostete Code ist nicht von mir, habs es vom Internet, aber Endergebnis ist das gleiche wie meine. Wie oben geshcrieben kann ich meins nicht posten. Daher habe ich nach einem ähnlichen Code gesucht. Kann mir jemand da weiterhelfen

Ich danke für die bisherigen antworten.

Gruss
prashanna

 

[Kevin94]

Wenn du es unbedingt wissen willst, auch wenn es sinnlos ist:

System.out.println(Integer.toHexString(data.hashCode()));

bzw. für binäre Darstellung: Integer.toBinaryString