Best way to move 8 bits into 8 individual bytes

Question

I have a status register with 8 bits. I would like to move each individual bit to a byte for further processing. Seems like it should be easy but every solution I come up with is convoluted. I was thinking about iterating through the bits with a for next loop and dumping them into an array but my solution way too messy.

Answer 1

Here's basically what you're trying to do. It uses bitwise operators and a uint8_t array to make each bit an individual byte:

void bits_to_bytes(uint8_t status, uint8_t bits[8])
{
    int ctr;
    for( ctr = 0; ctr < 8; ctr++ )
    {
        bits[ctr] = (status >> ctr) & 1;
    }
}

OK, so a little more in-depth:

This code loops through the bits in a byte and then assigns bits[bit_number] to the bit_numberth bit of status.

If you want to reverse the order the bits are stored in, simply change bits[ctr] to bits[(8-1)-ctr].

Answer 2

For a start, you should be using uint8_t for eight-bit bit collections since char is fundamentally non-portable unless you add a lot of extra code for checking its size and signedness.

Something like this should suffice for your needs:

void BitsToBytes(uint8_t bits, uint8_t *bytes) {
    for (int i = 0; i < 8; ++i) {     // The type has exactly eight bits.
        *bytes++ = (bits > 127);      // 1 if high bit set, else 0.
        bits = (bits & 0x7f) << 1;    // Shift left to get next bit.
    }
}
:
// Call with:
uint8_t inputBits = 0x42;
uint8_t outputBytes[8];
BitsToBytes(inputBits, outputBytes);

This takes a type with eight bits and a buffer of eight bytes, then places the individual bits into each byte of the array:

              MSB  LSB
             +--------+
inputBits:   |abcdefgh|
             +--------+
             +---+---+---+---+---+---+---+---+
outputBytes: | a | b | c | d | e | f | g | h |
             +---+---+---+---+---+---+---+---+

If you want it to go the other way (where the LSB of the input is in element 0 of the array), you can simply change the body of the loop to:

*bytes++ = bits & 1; // 1 if low bit set, else 0.
bits = bits >> 1;    // Shift right to get next bit.

Answer 3

You can use a double invocation of the ! operator to squash a zero/non-zero value to zero/one. Using this, the extracted value of bit n in status is !!(status & (1 << n)).

If you only have eight flags you might just create constants for the 8 values of 1 << n (0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80). This works particularly well if your flags all have individual names rather than numbers, so that you might have in a header file somewhere:

#define FLAG_FROB 0x01
#define FLAG_FOO  0x02
#define FLAG_BAR  0x04
#define FLAG_BAZ  0x08
#define FLAG_QUUX 0x10

Then in the code you'd just extract them as

flag_frob = !!(status & FLAG_FROB);
flag_foo = !!(status & FLAG_FOO);
flag_bar = !!(status & FLAG_BAR);
flag_baz = !!(status & FLAG_BAZ);
flag_quux = !!(status & FLAG_QUUX);