Как я могу отделить каждый бит от байта?

Я очень новичок в С# (и вообще C в целом). Я получаю байтовое значение, возвращаемое из внешнего источника, представляющего состояния 8 входных контактов на порту устройства ввода-вывода, поэтому я получаю значение 0-255, представляющее двоичный шаблон, присутствующий на порту.

Как я могу разделить отдельные биты и установить их как bool vars, поэтому сделаем что-то вроде этого:

if (inputBuffer[1] == 1)
{
     IO.Input0 = true;
     IO.Input1 = false;
     IO.Input2 = false;
     IO.Input3 = false;
     IO.Input4 = false;
     IO.Input5 = false;
     IO.Input6 = false;
     IO.Input7 = false;
}

Я, вероятно, слишком разбираюсь в том, что я пытаюсь достичь, но думал, что это дает лучший пример, хотя он очень непрактичен, как я могу добиться этого, чтобы установить переменные на основе байтового значения 0-255.

Ответы

Ответ 1

Используйте поразрядное и (&). Предполагая, что Input0 представляет наименее значащий бит:

IO.Input0 = (inputBuffer & 0x01) == 0x01;
IO.Input1 = (inputBuffer & 0x02) == 0x02;
IO.Input2 = (inputBuffer & 0x04) == 0x04;
IO.Input3 = (inputBuffer & 0x08) == 0x08;
IO.Input4 = (inputBuffer & 0x10) == 0x10;
IO.Input5 = (inputBuffer & 0x20) == 0x20;
IO.Input6 = (inputBuffer & 0x40) == 0x40;
IO.Input7 = (inputBuffer & 0x80) == 0x80;

Вы также можете реализовать метод расширения, например:

public static bool IsBitSet(this byte b, int bit)
{
    if(bit < 0 || bit > 7)
        throw new ArgumentOutOfRangeException("bit must be between 0 and 7");

    byte bitToCheck = (byte)(0x01 << bit);

    return (b & bitToCheck) == bitToCheck;
}

Что вы могли бы тогда назвать:

IO.Input4 = inputBuffer.IsBitSet(4);

Ответ 2

Используйте битмаску и & -оператор, чтобы понять это.

byte b = 100;

if(b&1 == 1) { } //bit 1 is set
if(b&2 == 2) { } //bit 2 is set
if(b&4 == 4) { } //bit 3 is set
...

Ответ 3

Я думаю, что сам письменный класс может помочь. Класс может содержать 8 бит, а конструктор принимает байт. В конструкторе вы можете вычислить отдельные биты.

public class myByte
{
    bool    Input0 = false;
    bool    Input1 = false;
    bool    Input2 = false;
    bool    Input3 = false;
    bool    Input4 = false;
    bool    Input5 = false;
    bool    Input6 = false;
    bool    Input7 = false;        

    public myByte(byte b)
    {
        //written by Ic.
        Input0 = b & 0x01 == 0x01;
        Input1 = b & 0x02 == 0x02;
        Input2 = b & 0x04 == 0x04;
        Input3 = b & 0x08 == 0x08;
        Input4 = b & 0x10 == 0x10;
        Input5 = b & 0x20 == 0x20;
        Input6 = b & 0x40 == 0x40;
        Input7 = b & 0x80 == 0x80;
    }
    ... //getter setter ...
}

Ответ 4

Вы можете сделать это.

int x= inputBuffer[1];

bit1 = ((x>>7)&1==1);
bit2 = ((x>>6)&1==1);
bit3 = ((x>>5)&1==1);
bit4 = ((x>>4)&1==1);
bit5 = ((x>>3)&1==1);
bit6 = ((x>>2)&1==1);
bit7 = ((x>>1)&1==1);
bit8 = (x&1==1);

Чтобы получить 1-й бит от значения 11101110, вам нужно вправо сдвинуть первый бит 7 раз, а затем выполнить операцию И с 1, сообщит вам, является ли значение 1 или 0, а одно и то же решение применимо и к другим битам.

Ответ 5

Если данные передаются вам в форме байта и что каждый бит был замаскирован, я оставил бы его как есть. Преобразование их в другой тип не требуется, это будет дополнительная работа без каких-либо преимуществ. Чтобы получить правильный бит, просто используйте шаблон битовой маски

private bool GetMaskedBit(var inputBuffer , int mask)
{
    return ((inputBuffer & mask) != 0);
}

Таким образом, вы разбираете буфер и необходимый бит, который вам нужен, это вернет, был ли бит установлен или нет.

Ответ 6

Вы можете использовать класс BitArray.

var bitArray = new BitArray(inputBuffer);
IO.Input1 = bitArray[byteIndex * 8 + 1];

или

var bitArray = new BitArray(new byte[] { inputBuffer[1] });
IO.Input1 = bitArray[1];

Вы также можете перебирать его как совокупность логических значений и выполнять побитовое управление во всей коллекции.

Это явно не так хорошо, как другие варианты, предлагаемые здесь (стоимость выделения), но он обеспечивает очень удобный API для вычисления бит.