Negative Zahl in Bytes prüfen

[Dennis89]

Hallo zusammen,

dieses mal geht es bei mir wieder um Bytes.
Ich bekomme zum Beispiel:

Code: Alles auswählen

b'qX\x1b\x00\x00\xff\xff\xff'

`b'q'`ist zur Prüfung, ob es sich um die Nachricht handelt, die ich erwarte. Die 3 `xff` werden immer zum Schluss gesendet und dazwischen befindet sich meine Zahl im little Endian.

Code: Alles auswählen

>> value = b'qX\x1b\x00\x00\xff\xff\xff'
>> int.from_bytes(value[1:5], 'little')
7000

Die Zahl -7000 wird mir so zurück gegeben:

Code: Alles auswählen

b'q\xa8\xe4\xff\xff\xff\xff\xff']/code]

[code="python"]>> value = b'q\xa8\xe4\xff\xff\xff\xff\xff'
>> int.from_bytes(value[1:5], 'little')
4294960296

Wenn ich das richtig verstanden habe, dann beginnt eine negative Zahl mit `xff` und da ich little Endian habe und "alle" negativen Zahlen, die ich getestet habe, mit `xff` enden, bin ich auf dem richtigen Weg(denke ich).
Es wäre doch aber falsch, nur dieses Byte gegen `xff` zu prüfen? Denn dasss ist ja grundsätzlich erst mal valide, weil ich vielleicht die Zahl 4294967295 benötige. Oder sagt man, dass man mit der Anzahl an Bytes nur eine gewisse größe an Zahl darstellen kann und wenn es größer ist, ist es negativ?


Danke und Grüße
Dennis

[Sirius3]

Negative Zahlen werden durch das Zweierkomplement dargestellt. Du mußt Dich also entscheiden, ob Du vorzeichenbehaftete Zahlen hast, oder nicht. Und wenn das feststeht, ist auch eindeutig klar, ob Du eine sehr große Zahl oder eine negative Zahl hast.

Code: Alles auswählen

int.from_bytes(value[1:5], 'little', signed=True)

[__blackjack__]

@Dennis89: Auf 0xFF prüfen wäre auch deshalb falsch, weil es ja nicht zwingend dieser Wert sein muss, auch bei einer negativen Zahl nicht:

Code: Alles auswählen

In [5]: value = b'q\xa8\xe4\xff\xf0\xff\xff\xff'

In [6]: value[1:5]
Out[6]: b'\xa8\xe4\xff\xf0'

In [7]: int.from_bytes(value[1:5], "little", signed=True)
Out[7]: -251665240

[Dennis89]

Danke für die Erklärungen, hat mir sehr weitergeholfen!


Grüße
Dennis

[Dennis89]

Es wird nicht besser bei mir. Hatte das alles nur am PC getestet. MicroPython ist da etwas anders:

https://docs.micropython.org/en/latest/ ... -parameter
Das gilt auch für `from_bytes()`

Habe mich gefragt, ob ich das mit dem Zweierkomplement jetzt selbst schreiben muss, dann habe ich das auf Github entdeckt:
https://github.com/micropython/micropython/issues/15399

Wenn ich das selbst schreiben könnte, dann wäre es vermutlich schon längst implementiert.

Sollte das meine Programmierkenntnisse überschreiten, dann würde ich die Hex-Darstellung an den Server senden, da wandeln und wenn es negativ ist, eine entsprechende Antwort an den ESP senden.

Grüße
Dennis

[__blackjack__]

@Dennis89: Zweierkomplement negieren ist einfach. Alle Bits ”kippen” und dann 1 addieren. Für die -7000 aus dem Beispiel:

Code: Alles auswählen

>>> 4294960296 ^ 0xFFFFFFFF
6999

>>> (4294960296 ^ 0xFFFFFFFF) + 1
7000

>>> -((4294960296 ^ 0xFFFFFFFF) + 1)
-7000

Und testen ob das umrechnen nötig ist, also ob man eine negative Zahl hat, ist ein einfacher Test ob das höchstwertige Bit gesetzt ist (negativ) oder nicht (positiv).

Code: Alles auswählen

>>> (4294960296 & 0x80000000) != 0
True

Alles Operationen die MicroPython können sollte.

Code: Alles auswählen

    data = ...
    value = int.from_bytes(data[1:5], "little")
    if value & 0x80000000:
        value = -((value ^ 0xFFFFFFFF) + 1)
    print(value)

Edit: Wenn man Zahlen haben kann die grösser sein können, als das was man mit den hier vier Bytes darstellen kann, dann kann man auch auch das hier machen:

Code: Alles auswählen

    value = int.from_bytes(data[1:5], "little")
    if value >= 0x80000000:
        value -= 0x100000000

[Sirius3]

Wenn micropython das Argument nicht kennt, dann benutze statt dessen struct:

Code: Alles auswählen

struct.unpack_from("<i", value, 1)[0]

[Dennis89]

Danke für die Antworten.

Mir fällt es schwer die Logik zu verstehen.
Ich kippe die Bits, also aus allen 1en mache ich 0en und andersrum. Das heißt, dass Bit das mir sagt ob es eine positive oder negative Zahl ist, ist jetzt, im Falle einer negativen Zahl, 0. Daher muss ich 1 addieren um wieder meinen ursprünglichen Wert zu haben. Das ist der Teil, den ich meine, verstanden zu haben.
Ich verstehe nicht wieso das funktioniert. Wieso kann ich immer die Bits kippen und bekomme meine Zahl? Ich verändere dadurch doch komplett alles. Das verwirrt mich gerade ziemlich.

Grüße
Dennis

[__blackjack__]

@Dennis89: Das funktioniert weil das so definiert ist. Könnte man auch anders definieren, dann sind die Schritte die Repräsentation einer Zahl zu negieren halt andere. Man könnte auch sagen, dass bei n Bits das höchstwertige Bit das Vorzeichen ist, und die anderen n-1 Bits den Zahlwert ganz normal als Binärzahl darstellen. Oder statt dem Zweierkomplement das Einerkomplement nehmen, also nur alle Bits umdrehen. Dann hätte man für 0 zwei Werte. Eine positive 0 wo kein Bit gesetzt ist und eine negative 0 wo alle Bits gesetzt sind.

Das Zweierkomplement hat die schöne Eigenschaft, dass man beispielsweise bei ganz normaler Bitweise Addition und Subtraktion von n-Bit langen Zahlen wo die Bits an Stellen grösser als n einfach weg fallen, die erwarteten Ergebnisse bekommt, ohne das man sich bei der Operation selbst Gedanken darüber machen muss ob die beteiligten Zahlen vorzeichenlos sein sollen oder nicht. Also wenn n beispielsweise 8 ist, also man ein Byte hat, dann ist ``(x + 255) & 0b1111_1111`` oder ``(x + -1) & 0b1111_1111`` ist als Code und Bitmuster des zweiten Operanden das gleiche, weil das Bitmuster des Ergebnisses das gleiche ist.