6 Nibble signed Hex-String korrekt anzeigen

roepke · 7. Februar 2025, 08:11

Hallo zusammen,
ich habe einen String der einen 6 Nibble langen hexadezimalen Wert enthält, z.B. "123456" (positiver Wert) oder "876543" (negativer Wert).
Diesen möchte ich nun in einem Label vorzeichenrichtig als signed Integer ausgeben.
Bei einem 4 Nibbel String mache ich das so:

VB.NET-Quellcode

Dim _i1 As Short = Convert.ToInt16("8111", 16) '_i1 = 8111
Dim _i2 As Integer = Convert.ToInt32(_i1) '_i2 = FFFF8111
Dim _s1 As String = _i2.ToString '_s1 = -32495

Wie bekomme ich das aber bei einem 6 Nibble HexWert hin?
Ich müsste den String ja zunächst vorzeichenrichtig auf 8 Nibble erweiteren, aber wie?
Und vorallem suche ich eine Möglichkeit diese Berechnung allgemein für Strings mit Längen <> 4, 8, 16 durchzuführen.

Haudruferzappeltnoch · 7. Februar 2025, 10:55

Convert.ToInt32("8111", 16) gibt 33041
Convert.ToInt16("8111", 16) gibt -32495

Da 008111 aber dasselbe ist wie 8111, ist hier natürlich die Frage warum das eine für dich richtig ist und das andere falsch. (Deswegen kommt bei 876543 auch kein negativer Wert)
Welche Einschränkung muss auf der resultierende Datentypgröße gemacht werden?

Bzw. hast du eine genaue Bitvorschrift für dein Ergebnis? Soll das ein 4*String.Length Bit Integer werden? Das wäre aber kein klassischer signed integer, die sind halt 32 bit lang

siycah · 7. Februar 2025, 11:57

Warum rechnest du bitte in Nibble? Ergibt doch gar keinen Sinn; kann kaum ein System was mit anfangen.
Die meisten ISAs sind auf Byte-Ebene unterwegs und das solltest du auch sein.

Du hast also ein 3-Byte Wert.
Dementsprechend gehört das in ein (minimum) 4 Byte Integer.

Mehr musst du auch gar nicht machen... Der Compiler bzw. die Runtime wird das für dich erledigen.

Hier mal ein Beispiel (in C++ wegen dem Union, aber ist in VB/C# sehr ähnlich).

C-Quellcode

#include <cstdint>
#include <iostream>
union AUnionForDifferentIntegerLengths {
uint8_t byte;
int8_t sbyte;
uint16_t ushort;
int16_t short_;
uint32_t uint;
int32_t int_;
uint64_t ulong;
int64_t long_;
};
int main() {
AUnionForDifferentIntegerLengths u{};
u.ulong = 0x876543;
printf("u.ulong = 0x%lx = %lu => \"%s\"\n", u.ulong, u.ulong, std::to_string(u.ulong).c_str());
printf("u.long_ = 0x%lx = %ld => \"%s\"\n", u.long_, u.long_, std::to_string(u.long_).c_str());
printf("u.uint = 0x%x = %u => \"%s\"\n", u.uint, u.uint, std::to_string(u.uint).c_str());
printf("u.int_ = 0x%x = %d => \"%s\"\n", u.int_, u.int_, std::to_string(u.int_).c_str());
printf("u.ushort= 0x%x = %u => \"%s\"\n", u.ushort, u.ushort, std::to_string(u.ushort).c_str());
printf("u.short_= 0x%x = %d => \"%s\"\n", u.short_, u.short_, std::to_string(u.short_).c_str());
printf("u.byte = 0x%x = %u => \"%s\"\n", u.byte, u.byte, std::to_string(u.byte).c_str());
printf("u.sbyte = 0x%x = %d => \"%s\"\n", u.sbyte, u.sbyte, std::to_string(u.sbyte).c_str());
}

Compilerbefehl: g++ -ointtest test.cpp
Ausgeführt mit: ./inttest

Ausgabe:

Quellcode

u.ulong = 0x876543 = 8873283 => "8873283"
u.long_ = 0x876543 = 8873283 => "8873283"
u.uint = 0x876543 = 8873283 => "8873283"
u.int_ = 0x876543 = 8873283 => "8873283"
u.ushort= 0x6543 = 25923 => "25923"
u.short_= 0x6543 = 25923 => "25923"
u.byte = 0x43 = 67 => "67"
u.sbyte = 0x43 = 67 => "67"

Wie du siehst, wird der Wert automatisch vom Compiler bzw. der Runtime bei dynamischen Zahlen angepasst. Geht ja auch nicht anders. Computer arbeiten nunmal mit Zweierpotenzen.

roepke · 7. Februar 2025, 14:06

Hallo zusammen,
@siycah ich rechne nicht in Nibbeln, ich bekomme diese als Daten.
Die Register im Zielsystem haben unterschiedliche Tiefen, manche sind 1, 2, 4, 6, 8... Byte, oder was auch immer tief.
Lese ich so ein Register kommt der gelesne Wert als "String" und ist eben 2, 4, 6, 8... Nibble lang.
Diesen Wert muss ich anzeigen, aber eben nciht Hex, so wie kommt, sondern als Integer, daher die Umrechnung.
Ich mache mit 24 Bit (6 Nibble) Strings jetzt folgendes:
-ich wandle nach Integer
-teste auf > 2^23 => wenn ja, dann ist der Wert negativ, andernfalls positiv
Schreibe mir das gerade als allgemeingültige Funktion, egal wie lang der String ist.

VB.NET-Quellcode

'ConvertHexValStringToSignedIntString(): wandelt einen hexadezimal String mit der Länge 1..8 in einen String um,
' der den Übergabestring als sigend Integer ausgibt.
Private Function ConvertHexValStringToSignedIntString(s As String) As String
Dim _iLength As Integer
Dim _sReturn As String = String.Empty
Dim _iSubtrahend As Integer = Convert.ToInt32(s, 16)
If s IsNot String.Empty Then
_iLength = s.Length
If _iLength > 8 Then
Return _sReturn
End If
Else
Return _sReturn
End If
'2 Nibble => 2^7 => _iSub = "000000FF"
'4 Nibble => 2^15 => _iSub = "0000FFFF"
'6 Nibble => 2^23 => _iSub = "00FFFFFF"
'8 Nibble => 2^31 => _iSub = "FFFFFFFF"
If _iSubtrahend >= 2 ^ ((_iLength * 4) - 1) Then
'Wert negativ
Dim _sMinuend As String = String.Empty
Dim _iMinuend As Integer = Convert.ToInt32(_sMinuend.PadRight(_iLength, "F"c), 16)
_sReturn = "-" & (_iMinuend - _iSubtrahend + 1).ToString
Else
_sReturn = _iSubtrahend.ToString
End If
Return _sReturn
's = "8000" => _sReturn = "-32768"
's = "FFFF" => _sReturn = "-1"
's = "FFFD" => _sReturn = "-3"
's = "1234" => _sReturn = "4660"
's = "8765" => _sReturn = "-30875"
's = "123456" => _sReturn = "1193046"
's = "876543" => _sReturn = "-7903933"
's = "12345678" => _sReturn = "305419896"
's = "87654321" => _sReturn = "-2023406815"
End Function

Beiträge zusammengefügt. ~Thunderbolt

Haudruferzappeltnoch · 7. Februar 2025, 18:17

Heißt ja noch lange nicht, dass ein 6 Nibble tiefes Register auch einen 24-bit Integer repräsentieren soll, für uns wirkt daher dein Präsentation als willkürlich.
Wem auch immer du die Zahl -7903933 in die Hand gibts, da wird der ne Weile nicht drauf kommen.

Hier der Trick:

VB.NET-Quellcode

Dim input = "876543"
Dim regularLong = Convert.ToInt64(input, 16) ' is 8873283
Dim test = CLng(1) << (input.Length * 4 - 1)
Dim weirdlong = regularLong
If test <= regularLong Then ' regular ist zu groß für input.Length
Dim mask = ((CLng(1) << (64 - input.Length * 4)) - 1) << (input.Length * 4) ' das sind die negativen 1en am Ende für die Konversion.
Dim weirdLong = mask + regularLong ' is -7903933
End If

roepke · 8. Februar 2025, 23:46

Bei uns im System sind die Registertiefen fest definiert. Es gibt 16 Bit signed und unsigned hex, genau wie 24 Bit signed und unsigend hex.
Die Inhalte werden IMMER als String gelesen dessen Daten IMMER der Registertiefe entsprechen und stellen i.d.R. Messwerte dar.
Somit ist klar, lese ich ein 16 Bit Rgister ist dieser Wert sicher max. 2^16 und ebenso 2^24 bei einem 24 Bit Register.
Normalerweise werden diese NIE als signed/unsigend Integer interpretiert, sondern sind ADC/DAC Werte die nach dem Lesen einfach in Integer gewandelt und mit Bitwertigkeiten multiplizeiert werden.
Da stellte sich nie die Frage der Darstellung des Rohwertes als signed/unsigend integer, wie es jetzt in eine Ausnamhe doch der Fall ist. Daher bin ich überhaupt über dieses Problem gestolpert.
Das die Daten als String kommen ist bei uns historisch. Wir nutzen eine Art Telnet Code in ASCII zum besseren Klartextlesen der Daten. Daher dieses "komische" Format.
Deinen Code probiere ich nächste Woche gerne mal aus. Danke dafür.

exc-jdbi · 9. Februar 2025, 16:33

Hab mal was ganz verrücktes gemacht.

Wollte wissen, ob man einen Pointer so gestalten kann, dass er genau diesen Anforderungen standhält. Die Lösung ist sehr einfach. Man macht einen Pointer der alle gewünschte Pointer-Ranges beinhaltet. Also einen für 16, einen für 24 und einen für 32. Der kleine Vorteil hier ist, man kann eine Byte-Strecke direkt mit dem Pointer durchlaufen, und erhält alle gewünschten Angaben.

Vielleicht kann es ja jemand gebrauchen.

Freundliche Grüsse

exc-jdbi

Samples

C#-Quellcode

private static void Samples1()
{
//s = "FFFF" => _sReturn = "-1"
//s = "FFFD" => _sReturn = "-3"
//s = "1234" => _sReturn = "4660"
//s = "8765" => _sReturn = "-30875"
//s = "123456" => _sReturn = "1193046"
//s = "876543" => _sReturn = "-7903933"
//s = "12345678" => _sReturn = "305419896"
//s = "87654321" => _sReturn = "-2023406815"
var sz1 = Unsafe.SizeOf<Int32_24_16>();
var sz2 = Marshal.SizeOf<Int32_24_16>();
var i0 = new Int32_24_16("FFFF");
var str = i0.ToString();
var i1 = new Int32_24_16("FFFD");
var i2 = new Int32_24_16("1234");
var i3 = new Int32_24_16("8765");
var i4 = new Int32_24_16("123456");
var i5 = new Int32_24_16("876543");
var i6 = new Int32_24_16("12345678");
var i7 = new Int32_24_16("87654321");
var i8 = new Int32_24_16("94989234");
var i9 = new Int32_24_16("91888630");
var i10 = new Int32_24_16("91821327");
var i11 = new Int32_24_16(i6);
var i12 = new Int32_24_16(i8.AsInteger());
}
private unsafe static void Samples2()
{
var rand = Random.Shared;
var size = rand.Next(10, 65);
if (int.IsOddInteger(size)) size--;
var tmp = new byte[size];
rand.NextBytes(tmp);
var hex = Convert.ToHexString(tmp);
var tsz = Unsafe.SizeOf<Int32_24_16>();
var i32xs = new Int32_24_16[hex.Length / tsz / 2];
var bytes = Convert.FromHexString(hex);
var str = string.Empty;
fixed (byte* ptr_bytes = bytes)
fixed (Int32_24_16* ptr_i32x = i32xs)
for (int i = 0; i < bytes.Length; i += tsz)
{
var ptr = (Int32_24_16*)(ptr_bytes + i);
*(ptr_i32x + i / tsz) = *ptr; //See variable i32xs
var h = (*(ptr_i32x + i / tsz)).ToHex();
str += h;
}
//The results can be found in the variable 'i32xs'.
//The pointer functions here as a simple "caster",
//which is iterated over the array of byte.
}

Pointer

C#-Quellcode

using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Diagnostics.CodeAnalysis;
namespace exc.jdbi.Pointers;
[StructLayout(LayoutKind.Explicit)]
public readonly struct Int32_24_16
{
[FieldOffset(0)]
private readonly I24 V0;
[FieldOffset(3)]
private readonly byte V3 = 0;
public static Int32_24_16 Zero => new();
public bool IsZero => this.V0.IsZero && this.V3 == 0;
public Int32_24_16(string hex)
{
var str_hex = hex.Length > 8 ? hex[..8] : hex;
var bytes = Convert.FromHexString(str_hex);
Array.Reverse(bytes);
this.V0 = new I24(bytes, 0);
if (bytes.Length > 3) this.V3 = bytes[3];
}
public Int32_24_16(string hex, int start_idx)
: this(hex[start_idx..])
{
}
public Int32_24_16(ReadOnlySpan<byte> bytes)
{
this.V0 = new I24(bytes, 0);
if (bytes.Length > 3) this.V3 = bytes[3];
}
public Int32_24_16(ReadOnlySpan<byte> bytes, int start_idx)
: this(bytes[start_idx..])
{
}
public Int32_24_16(int number)
: this(BitConverter.GetBytes(number))
{
}
public Int32_24_16(long number)
: this(BitConverter.GetBytes(number))
{
}
public Int32_24_16(Int32_24_16 number)
: this(number.AsInteger())
{
}
public int AsInteger() =>
Convert.ToInt32(this.ToString());
public string ToHex()
{
var bytes = this.ToBytes();
var sz = ToSize(bytes);
return Convert.ToHexString(bytes.Take(sz).ToArray()).ToUpper();
}
public override string ToString()
{
if (this.IsZero) return "0";
var bytes = this.ToBytes();
var sz = ToSize(bytes);
var result = BitConverter.ToInt32(bytes);
var bits = 8 * sz;
if (result < (1L << (bits - 1)))
return result.ToString();
return (result - (1L << bits)).ToString();
}
public byte[] ToBytes()
{
var result = new List<byte>();
result.AddRange(this.V0.ToBytes());
result.Add(this.V3);
return [.. result];
}
private static int ToSize(ReadOnlySpan<byte> bytes)
{
var cnt = 0;
var length = bytes.Length;
for (var i = 0; i < length; i++)
if (bytes[^(i + 1)] == 0)
cnt++;
else break;
return length - cnt;
}
#region Equality Operators
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override bool Equals([NotNullWhen(true)] object? obj)
{
if (obj?.GetType() == typeof(Int32_24_16))
this.Equals((Int32_24_16)obj);
return false;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode()
{
return (this.V0.AsInteger() + 4 * this.V3).GetHashCode();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(Int32_24_16 other)
{
return this == other;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator ==(Int32_24_16 left, Int32_24_16 right)
{
return left.V0 == right.V0 && left.V3 == right.V3;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator !=(Int32_24_16 left, Int32_24_16 right)
{
return !(left == right);
}
#endregion
#region I24
[StructLayout(LayoutKind.Explicit)]
private readonly struct I24
{
[FieldOffset(0)]
private readonly I16 V0;
[FieldOffset(2)]
private readonly byte V2 = 0;
public static I24 Zero => new();
public bool IsZero => this.V0.IsZero && this.V2 == 0;
public I24(string hex)
{
var bytes = Convert.FromHexString(hex);
Array.Reverse(bytes);
this.V0 = new I16(bytes, 0);
if (bytes.Length > 2) this.V2 = bytes[2];
}
public I24(ReadOnlySpan<byte> bytes, int start_idx)
{
this.V0 = new I16(bytes, start_idx);
if (bytes.Length > start_idx + 2) this.V2 = bytes[start_idx + 2];
}
public int AsInteger() =>
Convert.ToInt32(this.ToString());
public override string ToString()
{
if (this.IsZero)
return "0";
var tmp = this.ToBytes();
var sz = ToSize(tmp);
var bytes = new byte[4];
Array.Copy(tmp, bytes, tmp.Length);
var result = BitConverter.ToInt32(bytes);
var bits = 8 * sz;
if (result < (1L << (bits - 1)))
return result.ToString();
return (result - (1L << bits)).ToString();
}
public byte[] ToBytes()
{
var result = new List<byte>();
result.AddRange(this.V0.ToBytes);
result.Add(this.V2);
return [.. result];
}
private static int ToSize(ReadOnlySpan<byte> bytes)
{
var cnt = 0;
var length = bytes.Length;
for (var i = 0; i < length; i++)
if (bytes[^(i + 1)] == 0)
cnt++;
else break;
return length - cnt;
}
#region Equality Operators
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override bool Equals([NotNullWhen(true)] object? obj)
{
if (obj?.GetType() == typeof(I24))
this.Equals((I24)obj);
return false;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode()
{
return (this.V0.AsInteger() + 3 * this.V2).GetHashCode();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(I24 other)
{
return this == other;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator ==(I24 left, I24 right)
{
return left.V0 == right.V0 && left.V2 == right.V2;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator !=(I24 left, I24 right)
{
return !(left == right);
}
#endregion
}
#endregion I24
#region I16
[StructLayout(LayoutKind.Explicit)]
private readonly struct I16
{
[FieldOffset(0)]
private readonly byte V0 = 0;
[FieldOffset(1)]
private readonly byte V1 = 0;
public static I16 Zero => new();
public bool IsZero => this.V0 == 0 && this.V1 == 0;
public I16(string hex)
{
var bytes = Convert.FromHexString(hex);
Array.Reverse(bytes);
if (bytes.Length > 0) this.V0 = bytes[0];
if (bytes.Length > 1) this.V1 = bytes[1];
}
public I16(ReadOnlySpan<byte> bytes, int start_idx)
{
if (bytes.Length < start_idx + 2)
throw new ArgumentOutOfRangeException(nameof(start_idx));
if (bytes.Length > start_idx + 0) this.V0 = bytes[start_idx + 0];
if (bytes.Length > start_idx + 1) this.V1 = bytes[start_idx + 1];
}
public int AsInteger() =>
Convert.ToInt32(this.ToString());
public override string ToString()
{
if (this.IsZero)
return "0";
var result = (int)this.V0;
result |= this.V1 << 8;
var tsz = Unsafe.SizeOf<I16>();
var bits = 8 * tsz;
if (result < (1L << (bits - 1)))
return result.ToString();
return (result - (1L << bits)).ToString();
}
public byte[] ToBytes => [this.V0, this.V1];
#region Equality Operators
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override bool Equals([NotNullWhen(true)] object? obj)
{
if (obj?.GetType() == typeof(I16))
this.Equals((I16)obj);
return false;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode()
{
return (this.V0 + 2 * this.V1).GetHashCode();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(I16 other)
{
return this == other;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator ==(I16 left, I16 right)
{
return left.V0 == right.V0 && left.V1 == right.V1;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool operator !=(I16 left, I16 right)
{
return !(left == right);
}
#endregion
}
#endregion I16
}

6 Nibble signed Hex-String korrekt anzeigen

6 Nibble signed Hex-String korrekt anzeigen

VB.NET-Quellcode

C-Quellcode

Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

C#-Quellcode

C#-Quellcode

Benutzer online 2

Ähnliche Themen

4 Benutzer haben hier geschrieben