Wert auf Änderung überpüfen

[Fohnbit]

Hallo!

Ich rufe Werte über eine ModBus RTU Schnittstelle ab:

// Put answer in ByteBuffer
ByteBuffer bb = ByteBuffer.allocate(97);
bb.put(buffer);


double phase1Voltage, phase2Voltage, phase3Voltage;

phase1Voltage = Float.intBitsToFloat(bb.getInt());
phase2Voltage = Float.intBitsToFloat(bb.getInt());
phase3Voltage = Float.intBitsToFloat(bb.getInt())

Nun möchte ich eine Methode bei jedem Wert aufrufen, wenn sich dieser geändert hat.

Folgendes ist klar:

if (phase1Voltage != Float.intBitsToFloat(bb.getInt())) {
phase1Voltage = Float.intBitsToFloat(bb.getInt());
// Methode.xy ....
}

Da ich aber an die 100 Werte habe:
Kann man die Abfrage noch einfacher und eventuell performater machen?

Danke!

 

[Thallius]

Ich kann Dir nicht ganz folgen. Warum machst du das so kompliziert?

Du kannst doch einfach mit einer Schleife durch deinen Buffer gehen und immer wenn der Wert ungleich dem vorherigen ist, dann rufst du deine Methode auf.

Und warum wandelst du die Werte in Float? Das kostet doch nur Zeit und bringt gar nichts?

int value=bb.getInt();
for(int i=1; i<97; i++)
{
    int newValue=bb.getInt();
    if(newValue!=value)
        tueWas();
    value=newValue;
}

Gruß

Claus

 

[Fohnbit]

Hallo Claus!

Da hast du mich falsch verstanden oder ich habe es undeutlich geschrieben:
Ich bekomme alle 5 Sekunden einen 97 Byte langen Wert.
Darin sind Zählerinformationen, die ich lesen muss.

Ich muss also den Wert von vor 5 Sek auf änderung prüfen und nicht die Werte innerhalb des ByteBuffers.

Das Umrechnen ist nötig, da die Daten über Modbus gesendet werden und ich den Rohwert erst konvertieren muss.

 

[Thallius]

Das Umrechnen macht in meinen Augen aber immer noch keinen Sinn. Wen du ein getInt() in ein Float änderst bleibt das Ergebnis immer noch ein int. Das ist einfach Sinnfrei.

Und wenn du den Bluffer vergleichen willst, dann brquchstcdu ja auch zwei Buffet. Du hast aber nur einen in deinem Beispiel. Wo kommt denn der zweite her?

Gruß

Claus

 

[Harry Kane]

ich stimme Claus zu: Einlesen eines 4 byte int Wert, Konvertieren in einen 4 Byte float und dann einem 8 byte double zuweisen, sieht komisch aus. Ausserdem muss man beim Vergleichen von Fliesskommazahlen aufpassen.
Abgesehen davon: wie wäre es mit so einer Struktur:

int[] phaseVoltages = new int[100];
AnInterface[] methods = AnInterface[100];
//dann alle 5 Sekunden
for(int i = 0; i < 100; i++){
    int current = bb.getInt;
	if(phaseVoltages[i] != current){
	    phaseVoltages[i] = current;
		methods[i].valueChanged);
	}
}

AnInterface wäre dann so etwas wie Methode.xy in deinem obersten Post. Die Methode valueChanged() müsste dann jeeils so implemntiert werden, wie deine bereits vorhandenen Methoden.
Das klappt aber nur, wenn die ganzen Methoden, die du bei einer Wertänderung aufrufst, sich tatsächlich in einem Interface abbilden lassen, also z. B. einen ähnlichen oder gar identischen Satz an Parametern haben.

 

[arilou]

Mein Senf:
Du willst es performanter haben.

• Dann kannst du (wie bereits angeraten) auf die Wandlung nach Float verzichten und einfach prüfen, ob sich das neue Bitmuster vom alten unterscheidet (und es nur dann anschließend in einen Float wandeln).
• Wie viel Latenz ist denn erlaubt? Also: Wie schnell nach dem Eintreffen neuer Daten muss dein Programm das mitbekommen? Da nur alle 5 Sekunden neue Werte eintreffen, vermute ich mal, dass 1/10 s kein Problem ist - du kannst also zwischen zwei Abfragen 1/10 s warten:

  try{ Thread.sleep(100); } catch( InterruptedException iE) { }

  Dabei wartet Java mittels Timer, d.h. praktisch null CPU-Last.

 

[Fohnbit]

Hallo an alle!

Vielen Dank für die konstruktiven Vorschläge. Genau dies habe ich gesucht.

Jedoch zuerst:
Ich erhalte als ByteBuffer ein Bitmuster das ich in einen Doublewert am ende wandeln muss. Also nicht "nur" float to double.
Nachzulesen hier: IEEE 754
Ich nutze ja die intBitsToFloat Methode.

Aber arilou hat eine gute Idee. Ich kann ja das Bitmuster gespeichert lassen und bei einem neuem zuerst die Bitmuster auf Änderung prüfen. So muss ich nur konvertieren, wenn sich der Wert geändert hat.

 

[Fohnbit]

Habs nun mal so gemacht:

public void onReceive(byte b) {
		if (bbb1) {
			bb1.put(b);
		} else {
			bb2.put(b);
		}

		tail++;
	}

	public void onStreamClosed() {
		onMessage();
	}

	private void onMessage() {
		if (tail != 0) {

			// CRC16 berechnen noch auslagern
			Crc16 crc = new Crc16();

			if (bbb1) {
				for (int i = 0; i < bb1.capacity() - 2; i++) {
					crc.update(bb1.get(i));
				}

				bb1.position(bb1.capacity() - 2);
				int crcValue = bb1.getChar();

				if (bb1.get(0) != slaveId && !crc.compare(crcValue)
						&& bb1.get(1) != 0x04) {
					return;
				}
			} else {
				for (int i = 0; i < bb2.capacity() - 2; i++) {
					crc.update(bb2.get(i));
				}

				bb2.position(bb2.capacity() - 2);
				int crcValue = bb2.getChar();

				if (bb2.get(0) != slaveId && !crc.compare(crcValue)
						&& bb2.get(1) != 0x04) {
					return;
				}
			}

			// Phase 1 Voltage
			if (bb2.getInt(3) != bb1.getInt(3)) {
				phase1Voltage = Float.intBitsToFloat(bb2.getInt(3));
				System.out.println("phase1Voltage: " + phase1Voltage);
			}

			// Phase 2 Voltage
			if (bb2.getInt(7) != bb1.getInt(7)) {
				phase2Voltage = Float.intBitsToFloat(bb2.getInt(7));
				System.out.println("phase2Voltage: " + phase2Voltage);
			}

....

if (bbb1) {
				bb2.clear();
				bbb1 = false;
			} else {
				bb1.clear();
				bbb1 = true;
			}

			System.out
					.println("-----------------------------------------------");

			tail = 0;
		}
	}

Die CRC Abfrage kommt noch in eine eigene Methode.

Die ByteBuffer werden abwechselnd beschrieben und die Bitmuster verglichen. So muss ich nicht ein altes nicht in ein neues ByteArray kopieren und Zeit verschwenden.

Was ist von dieser Methode zu halten?

Vielen Dank!