Schleifen die nicht voneinander abhängen! (für CAN-BUS)

[Varjo]

Moin Leute,

ich habe folgendes Problem: Ich möchte einen grafischen Verlauf ananalysieren und daraus den CAN-Frame (0 oder 1) ermitteln. Dazu brauche ich einen String oder sonst was, wo Nullen und Einsen gespeichert werden können.

Nun habe ich mithilfe von Rechnungen(hier nicht wichtig) den Startpunkt herausgefunden. (l=6632) Nun soll eine For-Schleife vom Startpunkt an immer genau 160 Samples (entspricht g) weitergehen, damit er Bit für Bit durch den Graphen schaut. Dabei soll das Programm die Differenz y_var untersuchen und wenn diese im bereich -5<=y_var>=5 liegt im dem String dezi die "null" auf "eins" setzen. Hierbei ist zu beachten, das der String vorher auf Null initialisiert wurde.

Allerdings gibt er mir so immer alles 0 oder 1 aus. aber das ist nicht richtig. Lege ich irgendwas falsch an?

int l = 0;
String[] dezi = new String[128];
	  	Arrays.fill(dezi, "0");
	   
	   
	   	  	
	   
	   	
	   	//Umschreiben des Arrays, Bedingung abfragen
	  	
	   	int max_w = 5;
	   	int min_w = -5;
	   	
	   	
	   	for (l = 6632; l < valuesArray.length; l+=g)    //hier läuft er die Bits nach und nach ab
	   	{
	   		for (int b= 0; b < dezi.length; b++)
	   		{
				if(y_var[l] <= max_w & y_var[l] >= min_w) //hier prüft er die Differenzen die an dem jeweiligen Punkt liegen
				{
	   			dezi[b] = "1";
	   			//System.out.println("Wert:"+ dezi[b]);
				}
	  	
	   		}
	  	}

Vielen Dank im Vorraus für eure Hilfe.

LG Nils

 

[kaoZ]

Dazu brauche ich einen String oder sonst was, wo Nullen und Einsen gespeichert werden können.

String ist schon nicht unbeding die schlechtestes Wahl, du müsstest die Informationen dann aus dem String parsen, wie groß sind denn die Daten die du einlesen willst , und wie ließt du diese ein / speicherst du diese zwischen ?

Je nachdem wie du die Informationen erhälst könntest du diese auch direkt als byte oder integer in einem Array ablegen.

 

[Varjo]

ALso ich lese eine csv-Datei ein und speicher diese in einem Array. Da es drei Koordinaten ( x, y1,y2) sind kommen auch zwei Graphen zustande. Der eine ist positiv und der andere negativ, wodurch auch Differenzen zustande kommen, die ich dann in y_var speicher. y_var ist ein Array vom Datentyp Double, der ca. 65550 Werte speichert.
Der "neue" String der dann anch Abfrage nur noch "0" und "1" enthalten soll ich 128bit groß!

 

[kaoZ]

Das Stings an sich Immutable sind, würde ich dir , da ja das Grundgerüst schon zu stehen scheint, einen Stringbuilder zu nutzen und dementsprechend nach bedingung die Character an den jeweiligen stellen zu switchen, oder du arbeitest mit integern und nutzt bitshifting ( ~ ) um einfach die Bits umzukehren

wenn du natürlich , was man aus dem bisschen Code was bisher hier gepostet wurde leider nicht wirklich entnehmen kann, Werte in form von Integern aus den jeweiligen CSV Daten parst. und diese dann einfach als String ( Binär String ) darstellen willst kannst du das mit

Integer.toBinaryString(int i)

machen.
natürlich kann es auch sein das ich noch nicht zu 100 % durchblicke wo genau das Problem grade liegt

 

[Varjo]

Schon mal vielen Dank dafür, ich kann dir gerne nochmal den ganzen Code posten, vielleicht hilft dir das mehr!

 import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

import javax.swing.JOptionPane;

import org.csstudio.swt.xygraph.dataprovider.CircularBufferDataProvider;
import org.csstudio.swt.xygraph.figures.ToolbarArmedXYGraph;
import org.csstudio.swt.xygraph.figures.Trace;
import org.csstudio.swt.xygraph.figures.Trace.PointStyle;
import org.csstudio.swt.xygraph.figures.XYGraph;
import org.csstudio.swt.xygraph.util.XYGraphMediaFactory;
import org.eclipse.draw2d.LightweightSystem;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.csstudio.swt.xygraph.linearscale.LinearScale;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader.Array;



public class einlesen {


	//private static final Canvas SWT = null;

	public static void main(String[] args)
		{
		FileReader myFile = null;
		BufferedReader buff = null;
		final ArrayList<String> lines = new ArrayList<String>();

	    try {
	        myFile = new FileReader("data012.csv");
	        buff = new BufferedReader(myFile);
	        String line;
	       
	        while ((line = buff.readLine()) != null) 
	        	{
	            //System.out.println(line); // kontrolle was eingelesen
	 
	            lines.add(line);
	        	}

	    	} 
	    
	    catch (IOException e) 
	    	{
	        System.err.println("Error2 :" + e);
	    	} 
	    
	    finally 
	    {
	        try {
	            buff.close();
	            myFile.close();
	        	} 
	        		catch (IOException e) 
	        			{
	        			System.err.println("Error2 :" + e);
	        			}
	    }
	    
	    
	    
	 
	    final String[][] valuesArray = new String[lines.size()-13][3];
		final String[][] header = new String [13][2];

	    int cnt = 0;
		int cnt_header = 0;
	    int cnt_data = 0;
	    int i = 0;
	    
	    
	    //In den Header werden die ersten 13 Zeilen gepackt, da hier noch keine Koordinatendaten enthalten sind
	    //Die Koordinaten werden im valuesArray gespeichert, da ich eine x und zwei y komponeneten habe und daraus zwei graphen gemacht werden sollen,muss ich diese splitten
	    
	    
	    for (final String line : lines) 
	    	{
	    		if(cnt < 13)
	    		{
	    			header[cnt_header++] = line.split(";");
	    		}
	    		else
	    		{
	    			valuesArray[cnt_data++] = line.split(";");
	    		}
	    	cnt++;
	    	}
	    
	    
	   //Umwandlung des Strings in Koordinaten(Zahlen) 
	   double[]	 x_var = new double[valuesArray.length]; 
	   double[] y1_var = new double[valuesArray.length]; 
	   double[] y2_var = new double[valuesArray.length]; 
	   double[] y_var  = new double[valuesArray.length];
	   
	
	int j = 0;   
	   for (i = 0; i < valuesArray.length; i++)
	   	{
		 x_var[j]   = Double.parseDouble(valuesArray[i][0]);
		 y1_var[j] 	= Double.parseDouble(valuesArray[i][1]);
		 y2_var[j] 	= Double.parseDouble(valuesArray[i][2]);
		 y_var[j] = y1_var[j] - y2_var[j];
		 j++;
	   	}
	
		 
	   //Suche den Anfang des ersten Bits
	   
	   	int sollwert = 50;
	   
	   	for ( j = 0; j < valuesArray.length; j++)
	   	{
	   	 if(y_var[j] >= sollwert) 
	   	 {
	   		 System.out.println("Der Wert des ersten Bits ist: " + y_var[j] + " und liegt bei: " + j);
	   		 break;
	   	 }
	   	  
	   	}
	   	
	   	System.out.print("\n");
	   	
	   	//Ausgabe der Bitrate und Timebase, Berechnung der Samples pro Bit
	   	
	   	double z = Double.parseDouble(header[9][1]);
	   	System.out.println("Die Timebase beträgt: " + z + "s");
	   	
	   	
		double s = Double.parseDouble(header[12][1]);
	   	System.out.println("Die Bitrate beträgt:  " + s + " kBit/s");
	   	
	   	System.out.print("\n");
	   	
	   	//Berechnung 
	   	
	   	double t = 0;
	   	double g = 0;
	   	double x = 0;
	   	
	   	//Berechnung Zeit t für ein Bit und Samples g für ein Bit
	   	
	   	x = s *1000;
	   	System.out.println(s + " kBit/s sind: " + x + " Bit/s");
	   	
	   	t = 1 / x;
	   	System.out.println("Die Zeit für ein Bit beträgt: "+ t + "s");
	   	
	   	g = t / z;
	    System.out.println("Die Samples pro Bit betragen: " + g);
	   	
	   	
	   	System.out.print("\n");
	   	
	   	//Um die Binär-/Dezimalzahlen des CAN-Frames zu ermitteln, müssen die einzelnen Bit Bereiche abgetastet werden.
	   	//Hierzu wird am Anfang 60% der Samples die einem Bit entsprechen(160) weiter nach vorne gegangen und dann die Differenz y_var untersucht. 
	   	//Ist die Differenz "0" wird eine "1" in das CAN-Array geschrieben, bei der Differenz =! "0" ist eine "0" einzufügen. Anschließend geht es immer um 160 SAMples weiter.
	   	
	   	//Startpuntkt
	   	
	   	double spoint = (x_var[j])+(0.5*g);
	  	System.out.println("Der Startpunkt ist bei : " + spoint); //Überprüfung Startpunkt
	   	
	  	System.out.print("\n");
	  	
	  	int l = 0;
	  	String[] dezi = new String[128];
	  	Arrays.fill(dezi, "0");
	   
	
	   
	   	
	   	//Umschreiben des Arrays, Bedingung abfragen
	  	
	   	int max_w = 5;
	   	int min_w = -5;
	   	
	   	
	   	for (l = 6632; l < valuesArray.length; l+=g) 
	   	{
	   		for (int b= 0; b < dezi.length; b++)
	   		{
				if(y_var[l] <= max_w & y_var[l] >= min_w)
				{
	   			dezi[b] = "1";
	   			//System.out.println("Wert:"+ dezi[b]);
				}
	  	
	   		}
	  	}
	  	
	 
		
	 	
		//Erzeuge neues Fenster für denn Graph mit "Shell"
		final Shell shell = new Shell();
		shell.setSize(1024, 768);
	    shell.open();
	    
	    //use LightweightSystem to create the bridge between SWT and draw2D
		final LightweightSystem lws = new LightweightSystem(shell);
		
		//create a new XY Graph.
		XYGraph xyGraph = new XYGraph();
		xyGraph.setTitle("PCAN-Diag-Graph");
		
		ToolbarArmedXYGraph toolbarArmedXYGraph = new ToolbarArmedXYGraph(xyGraph);
		
		
		//set it as the content of LightwightSystem
		lws.setContents(toolbarArmedXYGraph);
		
		//Configure XYGraph
		xyGraph.primaryXAxis.setShowMajorGrid(true);
		xyGraph.primaryYAxis.setShowMajorGrid(true);
		xyGraph.primaryXAxis.setRange(0, 65550);
		xyGraph.primaryYAxis.setRange(50, 150);
		xyGraph.primaryYAxis.setAutoScale(true);
		xyGraph.primaryXAxis.setAutoScale(true);
		
		
		
		
		
		//create a trace data provider, which will provide the data to the trace.
		CircularBufferDataProvider traceDataProvider3 = new CircularBufferDataProvider(false);
		traceDataProvider3.setBufferSize(0xFFFF);		
		traceDataProvider3.setCurrentXDataArray(x_var);
		traceDataProvider3.setCurrentYDataArray(y_var);	
		
		//create the trace
		Trace trace3 = new Trace ("Trace1-XY Plot", 
				xyGraph.primaryXAxis, xyGraph.primaryYAxis, traceDataProvider3);			
		
		//set trace property
		trace3.setPointStyle(PointStyle.XCROSS);
		trace3.setTraceColor(XYGraphMediaFactory.getInstance().getColor(XYGraphMediaFactory.COLOR_BLACK) );
		
		//add the trace to xyGraph
		xyGraph.addTrace(trace3);
	  
		
		
		Display display = Display.getDefault();
	    while (!shell.isDisposed()) {
	      if (!display.readAndDispatch())
	        display.sleep();
	    }
	   
	   
	   
	  }
	
	
		
	
	}

 

[kaoZ]

//Die Koordinaten werden im valuesArray gespeichert, da ich eine x und zwei y komponeneten habe und daraus zwei graphen gemacht werden sollen,muss ich diese splitten

einfach nochmal um das Verständniss wegen , die die beiden y koordinaten sind einmal start und einmal Endpunkt auf der Grafischen Darstellung wobei einer dieser Werte Negativ sein muss (start) ? sprich eine Kurve und nicht nur eine einfach gerade?

Und du speicherst nur die Differenz ?

y_var[j] = y1_var[j] - y2_var[j];

 

[Varjo]

Ja genau, weil der (x/y1) graph eine Kurve ist und der (x/y2) graph die gleiche Kurve ist, nur an der x-Achse gespiegelt. Ich berechne nur die Differenz der y-Werte, weil dies für den CAN-Frame ausschlaggebend ist. Denn wenn diese Differenz minimal ist wird im CAN-Frame eine "1" geschrieben, wenn der sehr groß (>=50) ist dann eine "0".

Diese "0" und "1" Folge richtet sich dann nach der Differenz und soll in einem String/Array dargestellt werden, woraus dann später auch die Dezimalzahl berechnet werden soll.

Im folgenden Bild siehst du beide Kurve, die Differenz ist immer der Abstand der y-Werte voneinander.
Anhang anzeigen 6733

 

[kaoZ]

Diese "0" und "1" Folge richtet sich dann nach der Differenz und soll in einem String/Array dargestellt werden, woraus dann später auch die Dezimalzahl berechnet werden soll.

Funktioniert den schon das Grundprinzip und du möchtest jetzt lediglich die Darstellung als String realisieren ?

also sprich

Pseudo code

wenn(bedingung 1 || bedingung 2){
   string[i] = "0";
}
wenn nicht{
   string[i] = "1";
}

speicherst du denn jeweils nur eine "0" oder eine "1" pro string ?

dann würde ich auch dazu übergehen und ein char[] verwenden und dies später einfach in einen string konvertieren

 

[Varjo]

ja genau das Grundprinzip funktioniert und es soll nun nur noch der String mit 0 und 1 realisiert werden, aber wie bekomme ich dann alles aneinander? Aber er soll dabei die ganze Länge des eingelesenen Arrays durchgehen und sich jeden 160 Wert, nach dem Startwert anschauen, da das alles die einzelnen Bits sind!

 

[kaoZ]

Jetzt einfach mal stellvertretend für dein Array aus strings ( ich würde trotzdem char nehmen , wenn du eh immer nur ein Zeichen speichern willst )

public static void main(String[] args){
	
		String[] arr =
			{
				"0",
				"1",
				"0",
				"1"
			};
		
		StringBuilder builder = new StringBuilder();
		
		for (String string : arr) {
			builder.append(string);
		}
		
		System.out.println(builder.toString());
		
	}

Ausgabe : 

0101

Hier müsste dann noch eine if anweisung für deine 160 zeichen stattfinden.

Hier müsstenst du dann wieder mit einer normalen For-schleife arbeiten , und könntest dann z.B auch einfach nach jeden 160 Zeichen, einen neuen String über den Builder erstellen und diesen dann in ein neues Array ausgeben lassen , so das du dann immer die länge an informationen in einem String hast die du benötigst.

BTW. ich würde das ganze dann in einer Methode kapseln ! der du dann auch einfach einen Integer als parameter für deine Bedingung übergeben kannst, und der dir einfach deinen fertigen String als Rückgabe gibt.

ggf. auch einfach eine Rekursive Methode die dir dann solage noch felder im array über sind einen neuen string liefert

 

[Varjo]

Top, danke ich werde es mal so ausprobieren!