Immer Obere und untere byte von einem integer in C# und setzen es als ein char-array zum senden an einen com-port, wie?

In C würde ich dies tun

int Anzahl = 3510;

char oben = Zahl >> 8;

char lower = number && 8;

SendByte(oben);

SendByte(unten);

Wo Obere und untere würden beide = 54

In C# bin ich, dies zu tun:

            int number = Convert.ToInt16("3510");
            byte upper = byte(number >> 8);
            byte lower = byte(number & 8);
            char upperc = Convert.ToChar(upper);
            char lowerc = Convert.ToChar(lower);
            data = "GETDM" + upperc + lowerc;
            comport.Write(data);

Jedoch in der debugger-Nummer = 3510, oben = 13 und die untere = 0
das macht keinen Sinn, wenn ich den code >> 6 upper = 54, das ist absolut seltsam.

Im Grunde will ich nur, um die oberen und unteren byte von 16 bit-Zahl aus und senden Sie es an der com-port nach "GETDM"

Wie kann ich dies tun? Es ist so einfach in C, sondern in C# bin ich völlig ratlos.

InformationsquelleAutor rolls | 2011-03-24
  1. 33

    Ihre Maskierung ist falsch - Sie sollten in der Maskierung gegen 255 (0xff) anstelle von 8. Verlagerung der arbeiten in Bezug auf die "bits, um die verschoben werden, indem" in der Erwägung, dass bitweise und - /oder gegen den Wert zu Maske gegen... also, wenn Sie wollen, nur halten Sie die unteren 8 bits, Sie müssen eine Maske, die nur die unteren 8 bits festgelegt, d.h. 255.

    Beachten Sie, dass, wenn Sie versuchen, aufteilen einer Zahl in zwei bytes, es sollte wirklich kurz sein oder ushort, mit zu beginnen, nicht eine int (die vier bytes).

    ushort number = Convert.ToUInt16("3510");
byte upper = (byte) (number >> 8);
byte lower = (byte) (number & 0xff);

    Beachten Sie, dass ich verwendet habe ushort hier statt byte als bitweise Arithmetik ist leichter zu denken, wenn Sie nicht brauchen, um über Zeichen-Erweiterung. Wäre es nicht eigentlich egal, in diesem Fall durch die Art und Weise der einschränkende Konvertierung zu byte funktioniert, aber es ist die Art von Sache, die Sie denken sollten.

    • byte lower = (byte) number; tun sollten, wie gut
    • Stimmt, aber ich finde den Ansatz oben einfacher zu denken 🙂
    InformationsquelleAutor Jon Skeet
  2. 4

    Werden Sie wahrscheinlich wollen und es mit 0x00FF

    byte lower = Convert.ToByte(number & 0x00FF);

    Vollständigen Beispiel:

    ushort number = Convert.ToUInt16("3510");
byte upper = Convert.ToByte(number >> 8);
byte lower = Convert.ToByte(number & 0x00FF);
char upperc = Convert.ToChar(upper);
char lowerc = Convert.ToChar(lower);
data = "GETDM" + upperc + lowerc;
    InformationsquelleAutor SwDevMan81
  3. 2

    Sollte es nicht sein:

    byte lower = (byte) ( number & 0xFF );
    InformationsquelleAutor Nick
  4. 2

    Selbst wenn die akzeptierte Antwort passt zu der Frage, halte ich es für unvollständig, aufgrund der einfachen Tatsache, dass die Frage enthält int und nicht kurz im Kopf-und es ist irreführend, in den Suchergebnissen, und wie wir wissen, Int32 in C# hat 32 bits und somit 4 bytes. Ich poste hier ein Beispiel, das nützlich ist im Fall von Int32 verwenden. Im Falle eines Int32 wir haben:

    1. LowWordLowByte
    2. LowWordHighByte
    3. HighWordLowByte
    4. HighWordHighByte.

    - Und als solche habe ich die folgende Methode für die Umwandlung der Int32-Wert, der in einem little-endian-Hex-string, in dem jedes byte wird von den anderen getrennt durch ein Leerzeichen. Dies ist nützlich, wenn Sie Daten übertragen wollen und der Empfänger, um die Verarbeitung schneller, er kann nur Split(" ") und die bytes dargestellt als standalone-hex-strings.

    public static String IntToLittleEndianWhitespacedHexString(int pValue, uint pSize)
{
    String result = String.Empty;

    pSize = pSize < 4 ? pSize : 4;

    byte tmpByte = 0x00;
    for (int i = 0; i < pSize; i++)
    {
        tmpByte = (byte)((pValue >> i * 8) & 0xFF);
        result += tmpByte.ToString("X2") + " ";
    }

    return result.TrimEnd(' ');
}

    Verwendung:

    String value1 = ByteArrayUtils.IntToLittleEndianWhitespacedHexString(0x927C, 4);
String value2 = ByteArrayUtils.IntToLittleEndianWhitespacedHexString(0x3FFFF, 4);
String value3 = ByteArrayUtils.IntToLittleEndianWhitespacedHexString(0x927C, 2);
String value4 = ByteArrayUtils.IntToLittleEndianWhitespacedHexString(0x3FFFF, 1);

    Ist das Ergebnis:

    1. 7C 92 00 00
    2. FF FF 03 00
    3. 7C 92
    4. FF.

    Wenn es schwer zu verstehen ist die Methode, die ich erstellt habe, dann ist das folgende vielleicht ein verständlicher eins:

    public static String IntToLittleEndianWhitespacedHexString(int pValue)
{
    String result = String.Empty;
    byte lowWordLowByte = (byte)(pValue & 0xFF);
    byte lowWordHighByte = (byte)((pValue >> 8) & 0xFF);
    byte highWordLowByte = (byte)((pValue >> 16) & 0xFF);
    byte highWordHighByte = (byte)((pValue >> 24) & 0xFF);

    result = lowWordLowByte.ToString("X2") + " " +
            lowWordHighByte.ToString("X2") + " " +
            highWordLowByte.ToString("X2") + " " +
            highWordHighByte.ToString("X2");

    return result;
}

    Bemerkungen:

    1. Natürlich insteand uint pSize es kann eine enum-Angabe, Byte, Word, DoubleWord
    2. Stattdessen die Umwandlung in hex-string und die Schaffung der little-endian-string, können Sie konvertieren zu chars und tun, was Sie tun möchten.

    Hoffe, dies hilft jemand!

    InformationsquelleAutor XMight
  5. 1

    Werden ein wenig mehr Kreativität

    [System.Runtime.InteropServices.StructLayout( System.Runtime.InteropServices.LayoutKind.Explicit )]
public struct IntToBytes {
    [System.Runtime.InteropServices.FieldOffset(0)]
    public int Int32;
    [System.Runtime.InteropServices.FieldOffset(0)]
    public byte First;
    [System.Runtime.InteropServices.FieldOffset(1)]
    public byte Second;
    [System.Runtime.InteropServices.FieldOffset(2)]
    public byte Third;
    [System.Runtime.InteropServices.FieldOffset(3)]
    public byte Fourth;
}
    • Beachten Sie, dass dies nicht endian-sauber.
    InformationsquelleAutor MaLio
Schreibe einen Kommentar