Datentypen 2 8bit in ein 16bit in Java

[Pfeiffy]

Hallo,
ok, ich weiß - aber ich bin jetzt am Ende -
Frage: ich lese eine serielle Schnittstelle aus, hierbei kommt ein Wertebereich von -1800 bis +1800 zurück. Ich bekomme dies als 2 mal 8 bit und soll das 16bit berechnen. Bei alles positiv gar kein Problem. Aber bei negativ dreh ich durch.
z.b.:
-87 und 0 ergibt 169
-51 und -1 ergibt -510
82 und 1 ergibt 338 (klar --> 1 * 256 + 82 = 338, aber die anderen??
Gruß
Dirk

 

[Flown]

Byte die du erhälst sind signed oder unsigned?

 

[Pfeiffy]

UINT

 

[Thallius]

Eigentlich ganz einfach. Das erste Byte is immer unsigned. Somit kann diese nicht negativ werden. Du solltest sie als int empfangen und nicht als Byte, dann sollte dabei direkt 169 heraus kommen (Stichwort Zweierkomplement) -87 und 0 wäre hier nichts anderes als

00000000 10101001 = 169 (als 16 bit Zahl)

-51 und -1 wäre

10000001 11001101 = -461

Gruß

Claus

 

[Pfeiffy]

tut mir leid, ich habs noch nicht genau verstanden. Ich denke es überschreitet auch mein Wissen, wenn ich den Empfang der Daten umschreiben muss. Das sind meine Werte in verschiedenen Datentypen, ich weiß jetzt aber noch nicht, wie ich auf die Zahlen komme.
Value: 4 bi: 10101011 int: 171 byte: -85
Value: 5 bi: 0 int: 0 byte: 0
--> 171

Value: 6 bi: 11001110 int: 206 byte: -50
Value: 7 bi: 11111111 int: 255 byte: -1
--> -50

Value: 8 bi: 1010010 int: 82 byte: 82
Value: 9 bi: 1 int: 1 byte: 1
--> 338

 

[Thallius]

Du holst dir das erste Byte als int und das zweite als Byte. Dann kannst du die zahl sehr einfach berechnen mit

int value = erstesByteAlsInt;
value += zweitesByteAlsByte * 256;

Gruß

Claus

 

[Pfeiffy]

Super - ich bedanke mich vielmals für die Hilfe!!!!!!
Gruß
Dirk

 

[Meniskusschaden]

-51 und -1 wäre

10000001 11001101 = -461

Hm, mir kommt das noch seltsam vor. Ich hätte jetzt angenommen, dass man einfach die Bitmuster der beiden Werte aneinanderhängt und das Ergebnis als Zweierkomplement interpretiert. Dann würde ich aber auf folgendes Ergebnis kommen:

-1 = 11111111
-51 = 11001101
11111111 11001101 = -51

Und für -461 würde ich folgende Bytes bekommen:

-461 = 11111110 00110011
11111110 = -2
00110011 = 51

Meines Erachtens muss man aber einfach wissen, wie es in dem jeweiligen System festgelegt ist, also ob überhaupt im Zweierkomplement gearbeitet wird oder welches Byte nun LSB und MSB ist.

@Pfeiffy: Handelt es sich bei deinen Beispieldaten um garantiert korrekte Ergebnisse oder sind es deine Berechnungen, die noch in Frage stehen?

 

[Thallius]

@Meniskusschaden

Du hast rech. Das zweite war natuerlich Quatsch. Richtig wäre gewesen

1111111111001101

Ich war wohl bisschen daneben heute Mittag. Jetzt mit 2 Bier geht es besser 🙂

@to

Die richtige Art den Wert zu berechnen sollte eigentlich sein:

value = 256*256 - (erstesByteAlsInt + zweitesByteAlsInt * 256)
If(zweitesByteAlsInt >= 128)
    value = 256*256 - value

Gruß

Claus

 

[Pfeiffy]

oh, nun war ich so glücklich, dass es mit der ersten Formel geklappt hat - kommt ja auch das richtige raus - ich teste es jetzt auch mit der 2..
-> Nochmal eine Frage: wie mach ich es bei 4 unit8 als unit32?
Gruß
Pfeiffy

 

[Pfeiffy]

irgendwie...
Hier die Werte von der com:

Value: 0 bi: 1001101 int: 77 byte: 77
Value: 1 bi: 111110 int: 62 byte: 62
Value: 2 bi: 110 int: 6 byte: 6
Value: 3 bi: 1101100 int: 108 byte: 108
Value: 4 bi: 1111001 int: 121 byte: 121
Value: 5 bi: 0 int: 0 byte: 0
Value: 6 bi: 100101 int: 37 byte: 37
Value: 7 bi: 0 int: 0 byte: 0
Value: 8 bi: 1000101 int: 69 byte: 69
Value: 9 bi: 1 int: 1 byte: 1
Value: 10 bi: 1110010 int: 114 byte: 114

nach der neuen Formel:
angx = 256 * 256 - (intArray[4] + intArray[5] * 256);
if (intArray[5] >= 128) {
angx = 256 * 256 - angx;
}
;

kommt:
angx: 65415
-> die andere Formel war besser, richtig ist 121


angx: 65415 angy: 37 heading: 325

 

[Meniskusschaden]

die andere Formel war besser, richtig ist 121

Woher weißt du eigentlich, dass 121 richtig ist, wenn du gar nicht weißt, wie man es berechnet? Stimmt das Ergebnis denn auch bei negativen Werten?

nach der neuen Formel:
angx = 256 * 256 - (intArray[4] + intArray[5] * 256);
if (intArray[5] >= 128) {
angx = 256 * 256 - angx;
}
;
kommt:
angx: 65415

Ich glaube, die Formel war eher so gemeint:

value = erstesByteAlsInt + zweitesByteAlsInt * 256
If(zweitesByteAlsInt >= 128)
    value = 256*256 - value

Wahrscheinlich wollte er erst alles in eine Zeile packen, hat es sich dann anders überlegt und vergessen, die erste Zeile wieder zu bereinigen.

Nochmal eine Frage: wie mach ich es bei 4 unit8 als unit32?

Das müsste nach demselben Prinzip gehen. Die Wertigkeit jedes zusätzlichen Bytes ist um den Faktor 256 größer, als die des vorherigen Bytes.

 

[Pfeiffy]

Hallo,
ich weiß das Ergebnis, da ich ein fertiges Python-Programm und Cleanflight habe und ich dort die Werte sehen kann.
Wäre uint32 dann so? - Ergebnis ist im Micro-Fall (im Zimmer) ok:

        int wert32 = (intArray[startPointer] + intArray[startPointer+1] * 256 + intArray[startPointer+2] * 256
                + intArray[startPointer+3] * 256);
        if (intArray[startPointer] >= 128) {
            wert32 = 256 * 256 - wert32;
        }

 

[Meniskusschaden]

Wäre uint32 dann so? - Ergebnis ist im Micro-Fall (im Zimmer) ok:

 int wert32 = (intArray[startPointer] + intArray[startPointer+1] * 256 + intArray[startPointer+2] * 256
                + intArray[startPointer+3] * 256);
        if (intArray[startPointer] >= 128) {
            wert32 = 256 * 256 - wert32;
        }

Ich glaube nicht. Folgendes kommt mir plausibler vor (ungetestet):

int wert32 = (intArray[startPointer] + intArray[startPointer+1] * 256 + intArray[startPointer+2] * 256*256 + intArray[startPointer+3] * 256*256*256);
if (intArray[startPointer+3] >= 128) {
    wert32 = 256*256*256*256 - wert32;
}

 

[Tarrew]

Ist es nicht einfacher die Bytes einfach wieder zusammenzusetzen? Das wäre dann auch relativ variabel bezüglich der Anzahl der Bytes.

Also mal zwei Vorschläge:

public static long concatBytes(byte... values) {
    Long result = 0L;
    for (int i = values.length - 1; i >= 0; i--) {
        result <<= Byte.SIZE;
        result |= (-1 >>> (Long.SIZE - Byte.SIZE) & values[i]);
    }
    return result;
}

Den Rückgabewert müsste man dann immer casten. Also für die ersten 16 Bit auf short etc. zB:

short s = (short) concatBytes((byte) -87, (byte) 0);
System.out.println(s); //169

Bei einem int übergibt man entsprechend 4 Bytes und castet auf int.

Noch komfortabler wärs mit einem ByteBuffer:

byte[] array = new byte[]{-87, 0};
ByteBuffer b = ByteBuffer.wrap(array).order(ByteOrder.LITTLE_ENDIAN);
System.out.println(b.getShort()); //169

bzw. für ints:

byte[] array = new byte[]{-87, 1, 0,0};
ByteBuffer b = ByteBuffer.wrap(array).order(ByteOrder.LITTLE_ENDIAN);
System.out.println(b.getInt()); //425

Hoffe ich hab nichts übersehen 🙂

 

[Pfeiffy]

Hallo,
vielen dank - hab es schon eingebaut und es funktioniert.
Wie würde ich dann den Rückweg machen - d.h. einen int U16 in 2 oder U32 in 4 U8-Bytes aufteilen.

 

[Tarrew]

Entweder manuell:

public static byte[] intToByteArray(int value) {
    return new byte[]{
            (byte) value,
            (byte) (value >> 8),
            (byte) (value >> 16),
            (byte) (value >> 24)
    };
}

public static byte[] shortToByteArray(short value) {
    return new byte[]{
            (byte) value,
            (byte) (value >> 8),
    };
}

Oder einfach die die ByteBuffer.array() Methode nutzen. Weiß nicht welche Version von oben du verwendest, daher mal beide Möglichkeiten.