tipos - Obteniendo el byte superior e inferior de un entero en C#y poniéndolo como una matriz char para enviar a un puerto com, ¿cómo?

tipos de datos c#

Question

En CI haría esto

int número = 3510;

char superior = número >> 8;

char inferior = número && 8;

SendByte (superior);

SendByte (inferior);

Donde arriba y abajo serían ambos = 54

En C # estoy haciendo esto:

            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);

Sin embargo, en el número de depurador = 3510, superior = 13 y inferior = 0 esto no tiene sentido, si cambio el código a >> 6 superior = 54, lo cual es absolutamente extraño.

Básicamente solo quiero obtener el byte superior e inferior del número de 16 bits, y enviarlo al puerto de comunicación después de "GETDM"

¿Cómo puedo hacer esto? Es tan simple en C, pero en C # estoy completamente perplejo.

Answer 1

No debería ser:

byte lower = (byte) ( number & 0xFF );

Answer 2

Para ser un poco más creativo

[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;
}

Answer 3

Probablemente quieras y con 0x00FF

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

Ejemplo completo:

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;

Answer 4

Su enmascaramiento es incorrecto; debe estar enmascarando en lugar de 255 (0xff) en lugar de 8. El desplazamiento funciona en términos de "bits para cambiar por", mientras que en modo bit y / o trabajo contra el valor para enmascarar ... así que si solo desea mantén los 8 bits inferiores, necesitas una máscara que solo tenga el conjunto de 8 bits inferior, es decir, 255.

Tenga en cuenta que si intenta dividir un número en dos bytes, realmente debe ser un corto o ushort para empezar, no un int (que tiene cuatro bytes).

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

Tenga en cuenta que he utilizado ushort aquí en lugar de byte ya que la aritmética bit a bit es más fácil de pensar cuando no tiene que preocuparse por la extensión de los signos. En realidad, no importaría en este caso debido a la forma en que funciona la reducción del byte , pero es el tipo de cosas en las que debería pensar.

Answer 5

Incluso si la respuesta aceptada se ajusta a la pregunta, considero incompleta debido al simple hecho de que la pregunta contiene int y no corto en el encabezado y es engañosa en los resultados de búsqueda, y como sabemos Int32 en C # tiene 32 bits y por lo tanto 4 bytes . Voy a publicar aquí un ejemplo que será útil en el caso del uso de Int32. En el caso de un Int32 tenemos:

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

Y como tal, he creado el siguiente método para convertir el valor de Int32 en una pequeña cadena hexadecimal Endian, en la que cada byte está separado de los demás por un espacio en blanco. Esto es útil cuando transmite datos y desea que el receptor haga el procesamiento más rápido, puede simplemente dividir ("") y obtener los bytes representados como cadenas hexagonales independientes.

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('' '');
}

Uso:

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

El resultado es:

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

Si es difícil entender el método que creé, entonces el siguiente podría ser más comprensible:

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;
}

Observaciones:

1. Por supuesto, y de uint pSize, puede haber una enumeración que especifique Byte, Word, DoubleWord
2. En lugar de convertir a cadena hexadecimal y crear la pequeña cadena endian, puede convertir a caracteres y hacer lo que quiera hacer.

¡Espero que esto ayude a alguien!