Einlesen von Bytes

[Frank the B.]

Hallo,
also ich hab folgendes Problem und hoffe auf Eure Hilfe. I will von einer Datei Bytes einlesen, Messwerte von Sensoren. Nur leider gehen dabei Informationen verloren (ich gehe sogar von rund 2/3 Verlust aus). Das heißt also, dass ich nicht die gesamten Bytes bekomme, sondern immer nur ein paar.
Kann es vielleicht sein, dass die Daten zu schnell reinkommen und Java das nicht gebacken bekommt?
Hier mal Auszug meines Codes, nur dass Ihr seht, was ich nutz

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ReadingErec {
	public static void main(String[] args){
		
		File file = new File(Hier kommt Pfad für Datei rein);
		FileInputStream fileInput = null;
		try {
			fileInput = new FileInputStream(file);
		} catch (FileNotFoundException e1) {
		}
		DataInputStream dataInput = new DataInputStream(fileInput);
		
		byte readByte = 0;
		String temp = null;
		int i = 0;
		
		byte[] oneDataSerieRead = new byte[64];
		String[] stringData = new String[64];
		try {
			readByte = dataInput.readByte();
		} catch (IOException e) {}

		while (readByte != 0){
...

Gibt es sonst auch eine Möglichkeit in Java einzelne Bits einzulesen? Ich weiß sonst nicht mehr weiter....
Bin für jede Hilfe dankbar
MfG
Frank.

 

[Generic1]

>>Kann es vielleicht sein, dass die Daten zu schnell reinkommen und Java das nicht gebacken bekommt?

Das würd ich ausschließen,
Probier mal, den DataInputStream zu dekorieren mit einem BufferedInputStream

DataInputStream dataInput = new DataInputStream(fileInput);

 

[Spacerat]

Einzelne Bits...? Ist wohl ein Druckfehler (ist ja von Bytes die Rede), sonst wäre es

DataInputStream.readBoolean()

Wenn mann den gesammten Stream allerdings in einem ByteArray haben will geht folgendes:

ByteArrayOutputStream cp = new ByteArrayOutputStream();
FileInputStream in = new FileInputStream(file);
int r;
while((r = in.read()) != -1) cp.write(r);
in.close();
cp.close();
byte[] read = cp.toByteArray();

 

[tuxedo]

Wobei letzteres nicht unüberlegt eingesetzt werden sollte. Bei zu großen Files kann man damit den zur Verfügung stehenden Speicher recht schnell sprengen...
Am Besten und nach Möglichkeit nur den Teil im Speicher halten der auch gerade im Speicher gebraucht wird.

- Alex

 

[Frank the B.]

hi nochmal,
na das ging ja schnell mit den Antworten vielen Dank .
Leider klappt nichts von dem. Habs mit dem BufferedInput versucht und auch mit dem ByteArray und da gibts denselben Fehler....
Gibts noch eine Möglichkeit??

ps: Ich hab in drei Foren nachgefragt und Ihr seid die Ersten, die antworten VIelen Dank dafür.

 

[tuxedo]

Ähm, kannst du vllt. noch ein wenig mehr vom Code posten?

Was mich "verwirrt":

readByte = dataInput.readByte();

Du liest die Datei "byteweise", also ein byte nach dem anderen? Warum nicht blockweise? Und wo ist der Schleife die den Rest der Datei liest?

- Alex

 

[Spacerat]

Das hätte Klappen müssen... Da kommt mit Sicherheit irgendwo 'ne Exception (sprich Fehlermeldung). Davon bräuchte ich mal den Text...

BTW.: Tuxedo hat natürlich vollkommen Recht. Die Dateien sind hoffentlich nicht allzu gross.

 

[Frank the B.]

Also hier mal der Gesamte Code für die Klasse:

package readingErec;

import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Vector;

public class ReadingErec {
	
	File fileToOpen;
	FileInputStream fileInputForFileToOpen;
	DataInputStream dataInputStream;
	int oneByte;
	OnePackage onePackage = new OnePackage();
	
	
	public Vector<OnePackage> getFileToOpenAsVector(String pathToFile) throws IOException{
		
		Vector<OnePackage> output = new Vector<OnePackage>();
		
		fileToOpen = new File(pathToFile);
		System.out.println("Creating file...");
		
		fileInputForFileToOpen = new FileInputStream(fileToOpen);
		
		dataInputStream = new DataInputStream(fileInputForFileToOpen);
		System.out.println("Creating Stream...");
		int[] packet = new int[15];
		
		try{
			oneByte = dataInputStream.readUnsignedByte();
		} catch (Exception e){
		}
		System.out.println("Creating dataset...");
		while(dataInputStream.available() >= packet.length){
			if (oneByte == 255){
				for (int i = 0; i < packet.length; i++){
					packet[i] = dataInputStream.readUnsignedByte();
				}
				OnePackage temp = new OnePackage();
				temp.setPacket(packet);
				output.add(temp);
			}
		}
		return output;
	}
	public static void main(String[] args){
		ReadingErec erec = new ReadingErec();
		Vector<OnePackage> input = new Vector<OnePackage>();
		try {
			input = erec.getFileToOpenAsVector(Hier der Dateipfad);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if (input.size() > 0)
			System.out.println("All complete...");
	}
}

Hier die Klasse OnePackage, die nur dafür ist, jeweils ein Datenpacket zu speichern. Als Klasse, damit ich Vector nehmen kann.

package readingErec;

public class OnePackage {
	private int[] packet;
	
	public OnePackage(){
		this.packet = new int[15];
	}

	public int[] getPacket() {
		return packet;
	}

	public void setPacket(int[] packet) {
		this.packet = packet;
	}
}

Kurze Erklärung:
Ich bekomm immer Datensätze von jeweils 16 byte, wobei ein Byte mit dem Wert 255 (0xff) Start- bzw. Endbyte ist. Speichern tu ich jeweils einen Block von 16 byte in dem int array package. alle packages speicher ich in dem Vector input in der main methode. input bekommt den vector output bei der Methode.
Hoffe Ihr könnt damit was anfangen.
ps: wie kann man bytes denn blockweise einlesen?
mfg

 

[Spacerat]

Also...
1. OnePackage kann eliminiert werden... Vector<int[]> funktioniert auch.
2. Möglicherweise Nebensache, aber "getFileToOpenAsVector" wird ohne "close()" auf die Streams verlassen.

public class ReadingErec
{
  public Vector<int[]> getFileToOpenAsVector(String pathtofile) throws IOException
  {
    Vector<int[]> rc = new Vector<int[]>();
    FileInputStream in = new FileInput(pathtofilename);
    int bt;
    int cnt = 0;
    int[] buf = new int[16];
    while((bt = in.read()) != -1) { // bis Datei-Ende lesen
      buf[cnt++] = bt & 0xFF;
      cnt %= 16;
      if(cnt == 0) {
        rc.add(buf);
        buf = new int[16];
      }
    }
    in.close();
    return rc;
  }

  public static void main(String args[])
  {
    Vector<int[]> packets = null;
    try {
      packets = getFileToOpenAsVector(pathtofile); // möglicherweise arg[0]
    } catch(IOException ioe) {
      ioe.printStackTrace();
    }
    if(packets != null) System.out.println("Success");
  }
}

 

[Frank the B.]

Hey ja Danke für den Code. So läufts und ich bekomm alles was ich will
Vielen lieben, ich hoff ich kann das mal gut machen
mfg