Boolean Array and Bitwise Operation in C

Question

I have to implement a set of serial shift registers with each 8 outputs. The outputs are connected to switches, so I'm currently using boolean arrays in C that either turn the switch on (true) or off(false).

So each shift register has an array of 8 boolean values, which is in fact a 8 bit unsigned integer. I could continue to work with arrays but I assume thats a lot slower then just bitwise manipulating the integer. Also passing the integer to the SPI interface is a lot easier than an array.

Is there an easy way to convert boolean arrays into integers or manipulate the integers in the same way I could manipulate an array?

I.e.:

bool switch[8];
switch[0] = True; //Switch 1 on
switch[1] = False; //Switch 2 off
...

is the same as

uint8_t switch;
switch = 0b00000001;

But is harder to read and program when thinking in individual switches.

Performance is key, since my SPI needs to be very fast.

Answer 1

You cannot use the array syntax (this would need operator overloading, which is possible with C++). But you can use some helperfunction to set and get a bit (/ 8 and % 8 are optimized to bitshifts and ands, note that this is not the same with int as a type for index)

typedef uint8_t bit_mem_t;

static inline void set_bit(bit_mem_t* array, unsigned index, bool value) {
    array[index/8] = (array[index/8] | 1 << (index%8)) ^ !value << (index%8);
}

static inline bool get_bit(bit_mem_t const* array, unsigned index) {
    return (array[index/8] & 1 << (index%8)) != 0;
}

static inline void flip_bit(bit_mem_t* array, unsigned index) {
    array[index/8] ^= 1 << (index%8);
}

/*static inline size_t bit_array_size(size_t bit_count) {
    return (bit_count+7) / 8;
}*/
#define bit_array_size(bit_count) (((size_t)(count)+7)/8)

int main() {
    bit_mem_t array[bit_array_size(3)] {}; // clear it to 0s

    set_bit(array, 0, true);
    set_bit(array, 1, false);
    set_bit(array, 2, !get_bit(array, 1));
}

Answer 2

Use uint8_t for storing 8 bit hardware-related data, period. If it is a memory-mapped hardware register, it also needs to be volatile qualified.

If you wish to name individual pins you can do it with defines:

#define SWITCH3 (1u << 3);

Access with bitwise operators.

uint8_t switch = 0;
switch = SWITCH1 | SWITCH3;   // set all bits
switch |= SWITCH3;            // set a specific bit
switch &= (uint8_t)~SWITCH3;  // clear a specific bit

Answer 3

Use macros:

uint8_t sw;
#define SW_ON(s)    sw=(sw|(1u<<(s)))
#define SW_OFF(s)   sw=(sw&(~(1u<<(s))))

and use as:

SW_OFF(3);
SW_ON(2);

Answer 4

#define SWITCH1 1U
#define SWITCH2 2U
#define SWITCH3 4U
#define SWITCH4 8U
#define SWITCH5 16U
#define SWITCH6 32U
#define SWITCH7 64U
#define SWITCH8 128U


unsigned int switches = 0x0U;

To turn on a switch, lets says switch switch 4

switches = (switches | SWITCH4)

To turn off switch, lets says switch switch 4

switches = (switches & ~SWITCH4)

Answer 5

You could use a bitfield like that:

union {
     struct {
          unsigned char s1:1,
                        s2:1,
                        s3:1,
                        s4:1,
                        s5:1,
                        s6:1,
                        s7:1,
                        s8:1
     } sw;
    unsigned char nr[1];
} u;

You can access the fields individually (u.sw.s1 - u.sw.s8) for the switches, but also access the whole number in u.nr[0].

It might also be possible to use unsigned char nr instead of an array with 1 member, but the standard only declares it valid for char arrays, so better play it safe.